使用SpringBoot中整合Redis

开扎古的杂鱼

SpringBoot中整合Redis

本次，我们以IDEA + SpringBoot作为 Java中整合Redis的使用 的测试环境，如果对创建SpringBoot项目有不清楚的地方，可以参考这篇文章：使用Idea创建我的第一个SpringBoot项目
首先，我们需要导入Redis的maven依赖

1. <!-- Redis的maven依赖包 -->
   
2.         <dependency>
   
3.             <groupId>org.springframework.boot</groupId>
   
4.             <artifactId>spring-boot-starter-data-redis</artifactId>
   
5.         </dependency>

复制代码

其次，我们需要在配置文件中配置你的Redis配置信息，我使用的是 .yml文件格式

1. # redis配置
   
2. spring:
   
3.   redis:
   
4.     # r服务器地址
   
5.     host: 127.0.0.1
   
6.     # 服务器端口
   
7.     port: 6379
   
8.     # 数据库索引（默认0）
   
9.     database: 0
   
10.     jedis:
    
11.       pool:
    
12.         # 连接池最大连接数（使用负值表示没有限制）
    
13.         max-active: 50
    
14.         # 连接池最大阻塞等待时间（使用负值表示没有限制）
    
15.         max-wait: 3000ms
    
16.         # 连接池中的最大空闲连接数
    
17.         max-idle: 20
    
18.         # 连接池中的最小空闲连接数
    
19.         min-idle: 2
    
20.     # 连接超时时间（毫秒）
    
21.     timeout: 5000ms

复制代码

然后，我们需要创建一个RedisUtil来对Redis数据库进行操作

1. package com.zyxx.test.utils;
   
2. import org.springframework.beans.factory.annotation.Autowired;
   
3. import org.springframework.data.redis.core.RedisTemplate;
   
4. import org.springframework.stereotype.Component;
   
5. 
   
6. /**
   
7. * @ClassName RedisUtil
   
8. * @Author Lizhou
   
9. * @Date 2019-08-03 17:29:29
   
10. * @Version 1.0
    
11. **/
    
12. @Component
    
13. public class RedisUtil {
    
14. 
    
15.     @Autowired
    
16.     private RedisTemplate<String, String> template;
    
17. 
    
18.     /**
    
19.      * 读取数据
    
20.      *
    
21.      * @param key
    
22.      * @return
    
23.      */
    
24.     public String get(final String key) {
    
25.         return template.opsForValue().get(key);
    
26.     }
    
27. 
    
28.     /**
    
29.      * 写入数据
    
30.      */
    
31.     public boolean set(final String key, String value) {
    
32.         boolean res = false;
    
33.         try {
    
34.             template.opsForValue().set(key, value);
    
35.             res = true;
    
36.         } catch (Exception e) {
    
37.             e.printStackTrace();
    
38.         }
    
39.         return res;
    
40.     }
    
41. 
    
42.     /**
    
43.      * 根据key更新数据
    
44.      */
    
45.     public boolean update(final String key, String value) {
    
46.         boolean res = false;
    
47.         try {
    
48.             template.opsForValue().getAndSet(key, value);
    
49.             res = true;
    
50.         } catch (Exception e) {
    
51.             e.printStackTrace();
    
52.         }
    
53.         return res;
    
54.     }
    
55. 
    
56.     /**
    
57.      * 根据key删除数据
    
58.      */
    
59.     public boolean del(final String key) {
    
60.         boolean res = false;
    
61.         try {
    
62.             template.delete(key);
    
63.             res = true;
    
64.         } catch (Exception e) {
    
65.             e.printStackTrace();
    
66.         }
    
67.         return res;
    
68.     }
    
69.    
    
70.         /**
    
71.      * 是否存在key
    
72.      */
    
73.     public boolean hasKey(final String key) {
    
74.         boolean res = false;
    
75.         try {
    
76.             res = template.hasKey(key);
    
77.         } catch (Exception e) {
    
78.             e.printStackTrace();
    
79.         }
    
80.         return res;
    
81.     }
    
82. 
    
83.         /**
    
84.      * 给指定的key设置存活时间
    
85.      * 默认为-1，表示永久不失效
    
86.      */
    
87.     public boolean setExpire(final String key, long seconds) {
    
88.         boolean res = false;
    
89.         try {
    
90.             if (0 < seconds) {
    
91.                 res = template.expire(key, seconds, TimeUnit.SECONDS);
    
92.             }
    
93.         } catch (Exception e) {
    
94.             e.printStackTrace();
    
95.         }
    
96.         return res;
    
97.     }
    
98. 
    
99.     /**
    
100.      * 获取指定key的剩余存活时间
     
101.      * 默认为-1，表示永久不失效，-2表示该key不存在
     
102.      */
     
103.     public long getExpire(final String key) {
     
104.         long res = 0;
     
105.         try {
     
106.             res = template.getExpire(key, TimeUnit.SECONDS);
     
107.         } catch (Exception e) {
     
108.             e.printStackTrace();
     
109.         }
     
110.         return res;
     
111.     }
     
112. 
     
113.         /**
     
114.      * 移除指定key的有效时间
     
115.      * 当key的有效时间为-1即永久不失效和当key不存在时返回false，否则返回true
     
116.      */
     
117.     public boolean persist(final String key) {
     
118.         boolean res = false;
     
119.         try {
     
120.             res = template.persist(key);
     
121.         } catch (Exception e) {
     
122.             e.printStackTrace();
     
123.         }
     
124.         return res;
     
125.     }   
     
126. }

复制代码

最后，我们可以使用单元测试来检测我们在RedisUtil中写的操作Redis数据库的方法

1. package com.zyxx.test;
   
2. import com.zyxx.test.utils.RedisUtil;
   
3. import org.junit.Test;
   
4. import org.junit.runner.RunWith;
   
5. import org.springframework.boot.test.context.SpringBootTest;
   
6. import org.springframework.test.context.junit4.SpringRunner;
   
7. import javax.annotation.Resource;
   
8. 
   
9. @RunWith(SpringRunner.class)
   
10. @SpringBootTest
    
11. public class TestApplicationTest {
    
12. 
    
13.     @Resource
    
14.     private RedisUtil redisUtil;
    
15. 
    
16.     @Test
    
17.     public void setRedis() {
    
18.         boolean res = redisUtil.set("jay", "周杰伦 - 《以父之名》");
    
19.         System.out.println(res);
    
20.     }
    
21. 
    
22.     @Test
    
23.     public void getRedis() {
    
24.         String res = redisUtil.get("jay");
    
25.         System.out.println(res);
    
26.     }
    
27. 
    
28.     @Test
    
29.     public void updateRedis() {
    
30.         boolean res = redisUtil.update("jay", "周杰伦 - 《夜的第七章》");
    
31.         System.out.println(res);
    
32.     }
    
33. 
    
34.     @Test
    
35.     public void delRedis() {
    
36.         boolean res = redisUtil.del("jay");
    
37.         System.out.println(res);
    
38.     }
    
39. 
    
40.         @Test
    
41.     public void hasKey() {
    
42.         boolean res = redisUtil.hasKey("jay");
    
43.         System.out.println(res);
    
44.     }
    
45. 
    
46.         @Test
    
47.     public void expire() {
    
48.         boolean res = redisUtil.setExpire("jay", 100);
    
49.         System.out.println(res);
    
50.     }
    
51. 
    
52.     @Test
    
53.     public void getExpire() {
    
54.         long res = redisUtil.getExpire("jay");
    
55.         System.out.println(res);
    
56.     }
    
57. 
    
58.         @Test
    
59.     public void persist() {
    
60.         boolean res = redisUtil.persist("jay");
    
61.         System.out.println(res);
    
62.     }   
    
63. }

复制代码

推荐使用Redis客户端（redis-desktop-manager）来查看Redis数据库中的数据
至此，我们在日常项目中整合Redis的基本使用操作就完成了，但在实际项目中，可能会涉及到更复杂的用法，可以根据你的业务需求调整Redis的使用即可。

SpringBoot整合Redis改不了database问题

关于学习redis写的yaml文件，里面的

1. redis:
   
2.   database: 15
   
3.   host: 127.0.0.1
   
4.   port: 6379
   
5.   password:
   
6.   timeout: 3000ms # 连接超时时间（毫秒)

复制代码

但是springboot自动装配一直是database为0
最后发现是没有找到我配置的redis，默认是用的自动装配的默认地址（所以我一直以为我的yaml写对了，但是没用写对，因为一直没有取到我的值）
自动装配的就是

1. database=0，port=6379；无密码，host=localhost，

复制代码

就是因为这个原因，我写的数据能进入我的本地redis中，所以我一直没找到问题，因为我也使用的本地的redis测试的，一直找不到为什么改不了database。
最后发现是我的yaml文件的redis写错了，把redis写到log下面，并且归属于log。
最后该成归属于spring下面就可以了。
注意：一定要注意yaml的书写规范和上下级的关系。
深刻的教训，我在网上查了很多，也没找到对应的办法，幸好没有，不然的话，我的代码会被改的乱七八糟的，花了一下午才发现是自己yaml写错了。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持晓枫资讯。

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

若晴籍fyj

顶顶更健康！！！