Spring Boot 中使用 Redis

Redis 环境

redis 安装、配置，启动：（此处以云服务器上进行说明）

1. 下载地址：https://redis.io/download/
2. 下载后上传到云服务器上，如 /usr/local 中
4. gcc 环境安装：yum install -y gcc-c++
6. 解压：tar -zxvf xxx
8. 进入解压后的 redis 目录下执行
9. 编译：make
10. 安装：make install
12. 下载 redis/bin/redis.conf 进行下列配置后上传覆盖原文件：
13. 1. 注释掉 bind 127.0.0.1
14. 2. 设置 protected-mode 为 no
15. 3. 建议设置密码 requirepass xxx
17. 在 redis/bin 下执行命令使用配置文件方式后台启动 redis：
18. ./redis-server redis.conf &
20. 查看 redis 启动状态：
21. ps -ef|grep redis
23. 其他：
24. 关闭 redis：redis-cli shutdown
26. 连接问题参考：
27. 1. 终端执行，防火墙放行：firewall-cmd --zone=public --add-port=6379/tcp --permanent
28. 2. 终端执行，防火墙重启：firewall-cmd --reload
29. 3. 云服务器端口开放问题：在实例-》安全组管理中开放 6379 端口

复制代码

Spring Boot 中使用 Redis

1. 添加 pom

1. <dependency>
2.     <groupId>org.springframework.boot</groupId>
3.     <artifactId>spring-boot-starter-data-redis</artifactId>
4. </dependency>

复制代码

2. 添加配置

1. spring:
2.   redis:
3.     database: 0
4.     host: xxxxx      # Redis服务器地址，修改为你的地址
5.     port: 6379              # Redis服务器连接端口
6.     password: xxxxx          # Redis服务器连接密码（默认为空）
7.     timeout: 3000           # Redis服务器链接超时配置

复制代码

3. 导入 redis 工具类

PS：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.         // new RedisCallback<>() {
133.         //     @Override
134.         //     public Object doInRedis(RedisConnection redisConnection) throws DataAccessException {
135.         //         return null;
136.         //     }
137.         // };
138.         return (boolean) redisTemplate.execute((RedisCallback) connection -> {
139.             //获取锁
140.             /*
141.               setNX(k,v)：如果该键不存在，则设置该键的值为指定的字符串；否则不做任何事情；
142.               使用 setNX() 命令可以实现分布式锁等功能，因为该命令在设置键值对时是具有原子性的。
143.               在多线程或多进程环境中，如果多个线程或进程同时尝试使用 setNX() 命令来设置同一个键，
144.               只有一个线程或进程能够成功地设置，其他线程或进程会失败，从而实现了互斥操作。
145.              */
146.             return connection.setNX(key.getBytes(), String.valueOf(System.currentTimeMillis() + lockExpireMils + 1).getBytes());
147.         });
148.     }
150.     /**
151.      * 递增
152.      *
153.      * @param key   键
154.      * @param delta 要增加几(大于0)
155.      * @return
156.      */
157.     public long incr(String key, long delta) {
158.         if (delta < 0) {
159.             throw new RuntimeException("递增因子必须大于0");
160.         }
161.         // 将指定 key 的值增加 delta。如果 key 不存在，则会先创建一个初始值为 0 的 key，然后再执行增加操作。
162.         return redisTemplate.opsForValue().increment(key, delta);
163.     }
165.     /**
166.      * 递减
167.      *
168.      * @param key   键
169.      * @param delta 要减少几(小于0)
170.      * @return
171.      */
172.     public long decr(String key, long delta) {
173.         if (delta < 0) {
174.             throw new RuntimeException("递减因子必须大于0");
175.         }
176.         return redisTemplate.opsForValue().increment(key, -delta);
177.     }
179.     //================================Map=================================
181.     /**
182.      * HashGet
183.      *
184.      * @param key  键 不能为null
185.      * @param item 项 不能为null
186.      * @return 值
187.      */
188.     public Object hget(String key, String item) {
189.         return redisTemplate.opsForHash().get(key, item);
190.     }
192.     /**
193.      * 获取hashKey对应的所有键值
194.      *
195.      * @param key 键
196.      * @return 对应的多个键值
197.      */
198.     public Map<Object, Object> hmget(String key) {
199.         return redisTemplate.opsForHash().entries(key);
200.     }
202.     /**
203.      * HashSet
204.      *
205.      * @param key 键
206.      * @param map 对应多个键值
207.      * @return true 成功 false 失败
208.      */
209.     public boolean hmset(String key, Map<String, Object> map) {
210.         try {
211.             redisTemplate.opsForHash().putAll(key, map);
212.             return true;
213.         } catch (Exception e) {
214.             e.printStackTrace();
215.             return false;
216.         }
217.     }
219.     /**
220.      * HashSet 并设置时间
221.      *
222.      * @param key  键
223.      * @param map  对应多个键值
224.      * @param time 时间(秒)
225.      * @return true成功 false失败
226.      */
227.     public boolean hmset(String key, Map<String, Object> map, long time) {
228.         try {
229.             redisTemplate.opsForHash().putAll(key, map);
230.             if (time > 0) {
231.                 expire(key, time);
232.             }
233.             return true;
234.         } catch (Exception e) {
235.             e.printStackTrace();
236.             return false;
237.         }
238.     }
240.     /**
241.      * 向一张hash表中放入数据,如果不存在将创建
242.      *
243.      * @param key   键
244.      * @param item  项
245.      * @param value 值
246.      * @return true 成功 false失败
247.      */
248.     public boolean hset(String key, String item, Object value) {
249.         try {
250.             redisTemplate.opsForHash().put(key, item, value);
251.             return true;
252.         } catch (Exception e) {
253.             e.printStackTrace();
254.             return false;
255.         }
256.     }
258.     /**
259.      * 向一张hash表中放入数据,如果不存在将创建
260.      *
261.      * @param key   键
262.      * @param item  项
263.      * @param value 值
264.      * @param time  时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
265.      * @return true 成功 false失败
266.      */
267.     public boolean hset(String key, String item, Object value, long time) {
268.         try {
269.             redisTemplate.opsForHash().put(key, item, value);
270.             if (time > 0) {
271.                 expire(key, time);
272.             }
273.             return true;
274.         } catch (Exception e) {
275.             e.printStackTrace();
276.             return false;
277.         }
278.     }
280.     /**
281.      * 删除hash表中的值
282.      *
283.      * @param key  键 不能为null
284.      * @param item 项 可以使多个 不能为null
285.      */
286.     public void hdel(String key, Object... item) {
287.         redisTemplate.opsForHash().delete(key, item);
288.     }
290.     /**
291.      * 判断hash表中是否有该项的值
292.      *
293.      * @param key  键 不能为null
294.      * @param item 项 不能为null
295.      * @return true 存在 false不存在
296.      */
297.     public boolean hHasKey(String key, String item) {
298.         return redisTemplate.opsForHash().hasKey(key, item);
299.     }
301.     /**
302.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
303.      *
304.      * @param key  键
305.      * @param item 项
306.      * @param by   要增加几(大于0)
307.      * @return
308.      */
309.     public double hincr(String key, String item, double by) {
310.         return redisTemplate.opsForHash().increment(key, item, by);
311.     }
313.     /**
314.      * hash递减
315.      *
316.      * @param key  键
317.      * @param item 项
318.      * @param by   要减少记(小于0)
319.      * @return
320.      */
321.     public double hdecr(String key, String item, double by) {
322.         return redisTemplate.opsForHash().increment(key, item, -by);
323.     }
325.     //============================set=============================
327.     /**
328.      * 根据key获取Set中的所有值
329.      *
330.      * @param key 键
331.      * @return
332.      */
333.     public Set<Object> sGet(String key) {
334.         try {
335.             return redisTemplate.opsForSet().members(key);
336.         } catch (Exception e) {
337.             e.printStackTrace();
338.             return null;
339.         }
340.     }
342.     /**
343.      * 根据value从一个set中查询,是否存在
344.      *
345.      * @param key   键
346.      * @param value 值
347.      * @return true 存在 false不存在
348.      */
349.     public boolean sHasKey(String key, Object value) {
350.         try {
351.             return redisTemplate.opsForSet().isMember(key, value);
352.         } catch (Exception e) {
353.             e.printStackTrace();
354.             return false;
355.         }
356.     }
358.     /**
359.      * 将数据放入set缓存
360.      *
361.      * @param key    键
362.      * @param values 值 可以是多个
363.      * @return 成功个数
364.      */
365.     public long sSet(String key, Object... values) {
366.         try {
367.             return redisTemplate.opsForSet().add(key, values);
368.         } catch (Exception e) {
369.             e.printStackTrace();
370.             return 0;
371.         }
372.     }
374.     /**
375.      * 将set数据放入缓存
376.      *
377.      * @param key    键
378.      * @param time   时间(秒)
379.      * @param values 值 可以是多个
380.      * @return 成功个数
381.      */
382.     public long sSetAndTime(String key, long time, Object... values) {
383.         try {
384.             Long count = redisTemplate.opsForSet().add(key, values);
385.             if (time > 0) {
386.                 expire(key, time);
387.             }
388.             return count;
389.         } catch (Exception e) {
390.             e.printStackTrace();
391.             return 0;
392.         }
393.     }
395.     /**
396.      * 获取set缓存的长度
397.      *
398.      * @param key 键
399.      * @return
400.      */
401.     public long sGetSetSize(String key) {
402.         try {
403.             return redisTemplate.opsForSet().size(key);
404.         } catch (Exception e) {
405.             e.printStackTrace();
406.             return 0;
407.         }
408.     }
410.     /**
411.      * 移除值为value的
412.      *
413.      * @param key    键
414.      * @param values 值 可以是多个
415.      * @return 移除的个数
416.      */
417.     public long setRemove(String key, Object... values) {
418.         try {
419.             Long count = redisTemplate.opsForSet().remove(key, values);
420.             return count;
421.         } catch (Exception e) {
422.             e.printStackTrace();
423.             return 0;
424.         }
425.     }
426.     //===============================list=================================
428.     /**
429.      * 获取list缓存的内容
430.      *
431.      * @param key   键
432.      * @param start 开始
433.      * @param end   结束  0 到 -1代表所有值
434.      * @return
435.      */
436.     public List<Object> lGet(String key, long start, long end) {
437.         try {
438.             return redisTemplate.opsForList().range(key, start, end);
439.         } catch (Exception e) {
440.             e.printStackTrace();
441.             return null;
442.         }
443.     }
445.     /**
446.      * 获取list缓存的长度
447.      *
448.      * @param key 键
449.      * @return
450.      */
451.     public long lGetListSize(String key) {
452.         try {
453.             return redisTemplate.opsForList().size(key);
454.         } catch (Exception e) {
455.             e.printStackTrace();
456.             return 0;
457.         }
458.     }
460.     /**
461.      * 通过索引 获取list中的值
462.      *
463.      * @param key   键
464.      * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
465.      * @return
466.      */
467.     public Object lGetIndex(String key, long index) {
468.         try {
469.             return redisTemplate.opsForList().index(key, index);
470.         } catch (Exception e) {
471.             e.printStackTrace();
472.             return null;
473.         }
474.     }
476.     /**
477.      * 将list放入缓存
478.      *
479.      * @param key   键
480.      * @param value 值
481.      * @return
482.      */
483.     public boolean lSet(String key, Object value) {
484.         try {
485.             redisTemplate.opsForList().rightPush(key, value);
486.             return true;
487.         } catch (Exception e) {
488.             e.printStackTrace();
489.             return false;
490.         }
491.     }
493.     /**
494.      * 将list放入缓存
495.      *
496.      * @param key   键
497.      * @param value 值
498.      * @param time  时间(秒)
499.      * @return
500.      */
501.     public boolean lSet(String key, Object value, long time) {
502.         try {
503.             redisTemplate.opsForList().rightPush(key, value);
504.             if (time > 0) {
505.                 expire(key, time);
506.             }
507.             return true;
508.         } catch (Exception e) {
509.             e.printStackTrace();
510.             return false;
511.         }
512.     }
514.     /**
515.      * 将list放入缓存
516.      *
517.      * @param key   键
518.      * @param value 值
519.      * @return
520.      */
521.     public boolean lSet(String key, List<Object> value) {
522.         try {
523.             redisTemplate.opsForList().rightPushAll(key, value);
524.             return true;
525.         } catch (Exception e) {
526.             e.printStackTrace();
527.             return false;
528.         }
529.     }
531.     /**
532.      * 将list放入缓存
533.      *
534.      * @param key   键
535.      * @param value 值
536.      * @param time  时间(秒)
537.      * @return
538.      */
539.     public boolean lSet(String key, List<Object> value, long time) {
540.         try {
541.             redisTemplate.opsForList().rightPushAll(key, value);
542.             if (time > 0) {
543.                 expire(key, time);
544.             }
545.             return true;
546.         } catch (Exception e) {
547.             e.printStackTrace();
548.             return false;
549.         }
550.     }
552.     /**
553.      * 根据索引修改list中的某条数据
554.      *
555.      * @param key   键
556.      * @param index 索引
557.      * @param value 值
558.      * @return
559.      */
560.     public boolean lUpdateIndex(String key, long index, Object value) {
561.         try {
562.             redisTemplate.opsForList().set(key, index, value);
563.             return true;
564.         } catch (Exception e) {
565.             e.printStackTrace();
566.             return false;
567.         }
568.     }
570.     /**
571.      * 移除N个值为value
572.      *
573.      * @param key   键
574.      * @param count 移除多少个
575.      * @param value 值
576.      * @return 移除的个数
577.      */
578.     public long lRemove(String key, long count, Object value) {
579.         try {
580.             Long remove = redisTemplate.opsForList().remove(key, count, value);
581.             return remove;
582.         } catch (Exception e) {
583.             e.printStackTrace();
584.             return 0;
585.         }
586.     }
588.     /**
589.      * 模糊查询获取key值
590.      *
591.      * @param pattern
592.      * @return
593.      */
594.     public Set keys(String pattern) {
595.         return redisTemplate.keys(pattern);
596.     }
598.     /**
599.      * 使用Redis的消息队列
600.      *
601.      * @param channel
602.      * @param message 消息内容
603.      */
604.     public void convertAndSend(String channel, Object message) {
605.         redisTemplate.convertAndSend(channel, message);
606.     }
609.     //=========BoundListOperations 用法 start============
611.     /**
612.      * 将数据添加到Redis的list中（从右边添加）
613.      *
614.      * @param listKey
615.      * @param timeout 有效时间
616.      * @param unit    时间类型
617.      * @param values  待添加的数据
618.      */
619.     public void addToListRight(String listKey, long timeout, TimeUnit unit, Object... values) {
620.         //绑定操作
621.         BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
622.         //插入数据
623.         boundValueOperations.rightPushAll(values);
624.         //设置过期时间
625.         boundValueOperations.expire(timeout, unit);
626.     }
628.     /**
629.      * 根据起始结束序号遍历Redis中的list
630.      *
631.      * @param listKey
632.      * @param start   起始序号
633.      * @param end     结束序号
634.      * @return
635.      */
636.     public List<Object> rangeList(String listKey, long start, long end) {
637.         //绑定操作
638.         BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
639.         //查询数据
640.         return boundValueOperations.range(start, end);
641.     }
643.     /**
644.      * 弹出右边的值 --- 并且移除这个值
645.      *
646.      * @param listKey
647.      */
648.     public Object rightPop(String listKey) {
649.         //绑定操作
650.         BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
651.         return boundValueOperations.rightPop();
652.     }
654.     //=========BoundListOperations 用法 End============
656. }

复制代码

4. 测试

1. @RunWith(SpringRunner.class)
2. @SpringBootTest
3. public class MyTest {
5.     @Resource
6.     private RedisUtil redisUtil;
8.     @Resource
9.     private RedisTemplate<String, Object> redisTemplate;
11.     @Test
12.     public void test_redis_util() {
13.         boolean flag = redisUtil.set("key", "value");
14.         String v = (String) redisUtil.get("key");
15.         System.out.println("flag = " + flag + " v = " + v);
16.     }
18.     @Test
19.     public void test_redisTemplate() {
20.         ValueOperations<String, Object> ops = redisTemplate.opsForValue();
21.         ops.set("k1", "v1");
22.         System.out.println(ops.get("k1"));
23.     }
24. }   

复制代码

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