如何自定义redis工具jar包供其他SpringBoot项目直接使用

注：(最终redis数据库连接信息由使用者项目模块配置提供)

一、Redis常用存储操作实现（redis-util模块，该module最后会打包成jar供其他服务使用）

1.引用相关依赖

1. <!-- 如果有继承父级spring-boot-starter-parent，可不用添加版本号 -->
2. <!-- Redis缓存 [start] -->
3. <dependency>
4. <groupId>org.springframework.boot</groupId>
5. <artifactId>spring-boot-starter-data-redis</artifactId>
6. <version>2.3.0.RELEASE</version>
7. </dependency>
8. <!-- Redis缓存 [end] -->

2.配置reids连接信息

注：由于此时还处于redis-util工具包开发阶段，所以reids的配置文件还是由自己的模块来提供，后期打包成jar时，会清除redis-util工具包里的redis连接信息，然后由需要使用redis-util工具的服务模块提供reids的连接信息；
在reids-util的application.properties里配置redis数据库连接信息

1. #Redis服务器地址
2. spring.redis.host=127.0.0.1
3. #Redis服务器连接端口
4. spring.redis.port=6379
5. #Redis数据库索引（默认为0）
6. spring.redis.database=0

3.自定义序列化类，将存储在Redis的对象序列化为json格式

1. import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
2. import org.springframework.context.annotation.Bean;
3. import org.springframework.context.annotation.Configuration;
4. import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
5. import org.springframework.data.redis.core.RedisTemplate;
6. import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
7. import org.springframework.data.redis.serializer.StringRedisSerializer;
8.  
9. import java.io.Serializable;
10. @Configuration
11. @EnableAutoConfiguration
12. public class RedisConfig {
13. @Bean
14. public RedisTemplate<String, Serializable> redisTemplate(LettuceConnectionFactory redisConnectionFactory){
15. RedisTemplate<String, Serializable> template = new RedisTemplate();
16. template.setKeySerializer(new StringRedisSerializer());
17. template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
18. template.setHashKeySerializer(new StringRedisSerializer());
19. template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
20. template.setConnectionFactory(redisConnectionFactory);
21. return template;
22. }
23. }

4.开发相应的redis常用方法

1. package com.gh.redis.util;
2.  
3. import org.springframework.beans.factory.annotation.Autowired;
4. import org.springframework.data.redis.core.RedisTemplate;
5. import org.springframework.stereotype.Repository;
6. import org.springframework.util.CollectionUtils;
7.  
8. import java.io.Serializable;
9. import java.util.ArrayList;
10. import java.util.List;
11. import java.util.Set;
12. import java.util.concurrent.TimeUnit;
13.  
14. @Repository
15. public class RedisUtil {
16.  
17. @Autowired
18. RedisTemplate<String, Serializable> redisTemplate; // key-value是对象的
19.  
20. public RedisUtil(){
21.  
22. }
23.  
24. /**
25. * 判断是否存在key
26. * @param key 主键
27. * @return true或false
28. */
29. public boolean hasKey(String key) {
30. return Boolean.TRUE.equals(redisTemplate.hasKey(key));
31. }
32.  
33. /**
34. * 新增、修改Redis键值
35. * @param key 主键
36. * @param value 值
37. */
38. public void insertOrUpdate(String key, Serializable value) {
39. redisTemplate.opsForValue().set(key, value);
40. }
41.  
42. /**
43. * 新增、修改Redis键值,并设置有效时间（秒）
44. * @param key 主键
45. * @param value 值
46. * @param seconds 有效时间（秒）
47. */
48. public void insertOrUpdateBySeconds(String key, Serializable value, long seconds) {
49. redisTemplate.opsForValue().set(key, value, seconds, TimeUnit.SECONDS);
50. }
51.  
52. /**
53. * 新增、修改Redis键值,并设置有效时间（分）
54. * @param key 主键
55. * @param value 值
56. * @param minutes 有效时间（分）
57. */
58. public void insertOrUpdateByMinutes(String key, Serializable value, long minutes) {
59. redisTemplate.opsForValue().set(key, value, minutes, TimeUnit.MINUTES);
60. }
61.  
62. /**
63. * 新增、修改Redis键值,并设置有效时间（小时）
64. * @param key 主键
65. * @param value 值
66. * @param hours 有效时间（小时）
67. */
68. public void insertOrUpdateByHours(String key, Serializable value, long hours) {
69. this.redisTemplate.opsForValue().set(key, value, hours, TimeUnit.HOURS);
70. }
71.  
72. /**
73. * 新增、修改Redis键值,并设置有效时间（天）
74. * @param key 主键
75. * @param value 值
76. * @param days 有效时间（天）
77. */
78. public void insertOrUpdateByDays(String key, Serializable value, long days) {
79. this.redisTemplate.opsForValue().set(key, value, days, TimeUnit.DAYS);
80. }
81.  
82. /**
83. * 通过主键获取值
84. * @param key 主键
85. * @return
86. */
87. public Object get(String key) {
88. return redisTemplate.opsForValue().get(key);
89. }
90.  
91. /**
92. * 获取redis的所有key里包含pattern字符的key集
93. * @param pattern 模糊查询字符
94. * @return
95. */
96. public Set<String> getPattern(String pattern) {
97. return redisTemplate.keys("*" + pattern + "*");
98. }
99.  
100. /**
101. * 删除指定redis缓存
102. * @param key 主键
103. * @return
104. */
105. public boolean remove(String key) {
106. return Boolean.TRUE.equals(redisTemplate.delete(key));
107. }
108.  
109. /**
110. * 删除指定的多个缓存
111. * @param keys 主键1，主键2，...
112. * @return 删除主键数
113. */
114. public int removes(String... keys){
115. int count = 0;
116. List<String> deleteFails = new ArrayList<>();
117.  
118. for (String key : keys) {
119. if (Boolean.TRUE.equals(redisTemplate.delete(key))) {
120. ++count;
121. } else {
122. deleteFails.add(key);
123. }
124. }
125.  
126. if (!CollectionUtils.isEmpty(deleteFails)) {
127. System.err.println("======> Redis缓存删除失败的key：" + deleteFails.toString());
128. }
129. return count;
130. }
131.  
132. /**
133. * 删除所有的键值对数据
134. * @return 清除键值对数据量
135. */
136. public int removeAll(){
137. Set<String> keys = redisTemplate.keys("*");
138. Long delete = 0L;
139.  
140. if (keys != null) {
141. delete = redisTemplate.delete(keys);
142. }
143.  
144. return delete != null ? delete.intValue() : 0;
145. }
146.  
147. }

5.工具包开发完成，测试一下

1. import com.gh.common.toolsclass.ResultData;
2. import com.gh.redis.util.RedisUtil;
3. import org.junit.jupiter.api.Test;
4. import org.springframework.beans.factory.annotation.Autowired;
5. import org.springframework.boot.test.context.SpringBootTest;
6.  
7. import java.util.Set;
8.  
9. @SpringBootTest
10. class RedisApplicationTests {
11.  
12. @Autowired
13. private RedisUtil redisUtil;
14.  
15. @Test
16. void test1() {
17. ResultData resultData = new ResultData();
18. resultData.setCode(0);
19. resultData.setMessage("redis测试");
20. resultData.setData("666666");
21. redisUtil.insertOrUpdate("demo", resultData);
22. System.err.println(redisUtil.hasKey("demo"));
23. Object demo = redisUtil.get("demo");
24. ResultData bo = (ResultData) demo;
25. System.err.println(bo.toString());
26. }
27.  
28. @Test
29. void test2() {
30. Set<String> list = redisUtil.getPattern("l");
31. for (String s: list) {
32. System.err.println(s);
33. }
34. }
35. }

其中ResultData是自定义的一个用于返回信息的对象，可用其他对象替代，但是该对象需要实现Serializable接口（ResultData implements Serializable）

运行test1：

运行test2：

其他方法自行测试，这里不一 一展示；

6.清除redis数据库连接信息

自此redis-util工具包开发完成，可供其他服务使用，最后清除redis-util模块application.properties里的redis数据库连接信息。之后的连接信息由使用者模块提供，这样才符合redis-util作为一个纯工具包的定义。

二、创建一个consumer项目来引用redis-util工具包

1.在consumer项目的pom.xml中添加reids-utils的依赖

1. <!-- redis工具包 [start] -->
2. <dependency>
3. <groupId>com.gh</groupId>
4. <artifactId>redis-util</artifactId>
5. <version>0.0.1-SNAPSHOT</version>
6. </dependency>
7. <!-- redis工具包 [end] -->

pom如何引用自定义jar包依赖自行百度，如果在同一父工程模块下，可直接这么引用。不在同一父工程，需要先将jar包放到maven仓库。

2.在consumer的application.properties配置文件里添加redis数据的连接信息

1. #Redis服务器地址
2. spring.redis.host=127.0.0.1
3. #Redis服务器连接端口
4. spring.redis.port=6379
5. #Redis数据库索引（默认为0）
6. spring.redis.database=0

3.测试在cunsumer里是否可以使用redis-util工具包的方法

1. package com.gh.consumer;
2.  
3. import com.gh.common.toolsclass.ResultData;
4. import com.gh.redis.util.RedisUtil;
5. import org.junit.jupiter.api.Test;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.boot.test.context.SpringBootTest;
8.  
9. @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
10. class ConsumerApplicationTests {
11.  
12. // 这里使用该构造器注入的方式，因为使用变量注入
13. final RedisUtil redisUtil;
14.  
15. @Autowired
16. public ConsumerApplicationTests(RedisUtil redisUtil){
17. this.redisUtil = redisUtil;
18. }
19.  
20. @Test
21. void test1() {
22. // 如果存在demo缓存，就删除
23. if (redisUtil.hasKey("demo")) {
24. System.err.println(redisUtil.remove("demo"));
25. }
26. // 插入新的demo缓存
27. ResultData resultData = new ResultData();
28. resultData.setCode(0);
29. resultData.setMessage("redis测试-2");
30. resultData.setData("888888");
31. redisUtil.insertOrUpdate("demo", resultData);
32. Object demo = redisUtil.get("demo");
33. ResultData bo = (ResultData) demo;
34. System.err.println(bo.toString());
35. }
36.  
37. @Test
38. void test2() {
39. redisUtil.insertOrUpdate("test", "redis工具测试");
40. System.err.println(redisUtil.get("test"));
41. }
42.  
43. }

运行test1，此时会发现控制台提示找不到RedisUtil的bean

4.在启动类添加扫描

其他注解不用管，解决redis-util工具包bean扫描不到的问题，只需要添加注解@ComponentScan(value = “com.gh.redis.*”)就好

1. package com.gh.consumer;
2.  
3. import org.springframework.boot.SpringApplication;
4. import org.springframework.boot.autoconfigure.SpringBootApplication;
5. //import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
6. import org.springframework.cloud.openfeign.EnableFeignClients;
7. import org.springframework.context.annotation.ComponentScan;
8. import org.springframework.context.annotation.ComponentScans;
9. import org.springframework.scheduling.annotation.EnableScheduling;
10.  
11. //@EnableDiscoveryClient eureka开启发现服务功能
12. @EnableFeignClients(basePackages = "com.gh.consumer.feign")
13. //@ComponentScan(basePackages = "com.gh.consumer.*")
14. @ComponentScans(value = {
15. @ComponentScan(value = "com.gh.consumer.*")
16. ,@ComponentScan(value = "com.gh.redis.*")
17. })
18. @EnableScheduling // 开启定时任务功能
19. @SpringBootApplication
20. public class ConsumerApplication {
21.  
22. public static void main(String[] args) {
23. SpringApplication.run(ConsumerApplication.class, args);
24. }
25. }

5.再次测试

成功调用redis-utils工具包方法！

到此这篇关于如何自定义redis工具jar包供其他SpringBoot项目直接使用的文章就介绍到这了,更多相关redis工具jar包springboot使用内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！