devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Redis在SpringBoot项目中使用_stringredisserializer.utf_8

作者：我家自动化 | 2024-02-27 10:42:32

赞

踩

stringredisserializer.utf_8

完整版配置（pom.xml）

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3. 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4. 	<modelVersion>4.0.0</modelVersion>
  5. 	<parent>
  6. 		<groupId>org.springframework.boot</groupId>
  7. 		<artifactId>spring-boot-starter-parent</artifactId>
  8. 		<version>2.1.8.RELEASE</version>
  9. 		<relativePath/> <!-- lookup parent from repository -->
  10. 	</parent>
  11. 	<groupId>com.microStationCom</groupId>
  12. 	<artifactId>WebApi</artifactId>
  13. 	<version>0.0.1-SNAPSHOT</version>
  14. 	<name>WebApi</name>
  15. 	<!-- springboot 打war包。 默认打包方式为 jar , 这里修改为war -->
  16.  
  17. <!--	<packaging>war</packaging>-->
  18. 	<!-- -->
  19.     <packaging>jar</packaging>
  20. 	<description>microStationCom WebApi</description>
  21. 	<properties>
  22. 		<java.version>1.8</java.version>
  23. 		<tencent.qcloudsms.version>3.1.298</tencent.qcloudsms.version>
  24. 		<pagehelper.version>5.0.3</pagehelper.version>
  25. 	</properties>
  26. 	<dependencies>
  27. 		<dependency>
  28. 			<groupId>org.springframework.boot</groupId>
  29. 			<artifactId>spring-boot-starter-web</artifactId>
  30. 			<!--最终打成war包，排除内置的tomcat
  31. 			<exclusions>
  32. 				<exclusion>
  33. 					<groupId>org.springframework.boot</groupId>
  34. 					<artifactId>spring-boot-starter-tomcat</artifactId>
  35. 				</exclusion>
  36. 			</exclusions>
  37. 			-->
  38. 		</dependency>
  39.  
  40. 		<!-- reids -->
  41. 		<dependency>
  42. 			<groupId>org.springframework.boot</groupId>
  43. 			<artifactId>spring-boot-starter-data-redis</artifactId>
  44. 			<!-- 不依赖Redis的异步客户端lettuce -->
  45. 			<exclusions>
  46. 				<exclusion>
  47. 					<groupId>io.lettuce</groupId>
  48. 					<artifactId>lettuce-core</artifactId>
  49. 				</exclusion>
  50. 			</exclusions>
  51. 		</dependency>
  52.  
  53. 		<!-- Jedis客户端依赖，默认版本： jedis = 2.9.3 , commons-pool2 = 2.6.2 -->
  54. 		<dependency>
  55. 			<groupId>redis.clients</groupId>
  56. 			<artifactId>jedis</artifactId>
  57. 		</dependency>
  58. 		<dependency>
  59. 			<groupId>org.apache.commons</groupId>
  60. 			<artifactId>commons-pool2</artifactId>
  61. 		</dependency>
  62. 		<dependency>
  63. 			<groupId>commons-lang</groupId>
  64. 			<artifactId>commons-lang</artifactId>
  65. 			<version>2.3</version>
  66. 		</dependency>
  67.  
  68. 		<dependency>
  69. 			<groupId>com.microsoft.sqlserver</groupId>
  70. 			<artifactId>sqljdbc4</artifactId>
  71. 			<version>4.0</version>
  72. 			<scope>runtime</scope>
  73. 		</dependency>
  74.  
  75. 		<dependency>
  76. 			<groupId>com.alibaba</groupId>
  77. 			<artifactId>druid-spring-boot-starter</artifactId>
  78. 			<version>1.1.10</version>
  79. 		</dependency>
  80.  
  81. 		<dependency>
  82. 			<groupId>ch.qos.logback</groupId>
  83. 			<artifactId>logback-core</artifactId>
  84. 		</dependency>
  85.  
  86. 		<dependency>
  87. 			<groupId>commons-codec</groupId>
  88. 			<artifactId>commons-codec</artifactId>
  89. 			<version>1.9</version>
  90. 		</dependency>
  91.  
  92. 		<dependency>
  93. 			<groupId>org.springframework.boot</groupId>
  94. 			<artifactId>spring-boot-starter-test</artifactId>
  95. 			<scope>test</scope>
  96. 		</dependency>
  97.  
  98. 		<dependency>
  99. 			<groupId>org.projectlombok</groupId>
  100. 			<artifactId>lombok</artifactId>
  101. 			<optional>true</optional>
  102. 		</dependency>
  103. 		<!-- mybatis plus 代码生成器 -->
  104. 		<!--mybatis plus-->
  105. 		<dependency>
  106. 			<groupId>com.baomidou</groupId>
  107. 			<artifactId>mybatis-plus-generator</artifactId>
  108. 			<version>3.4.0</version>
  109. 		</dependency>
  110.  
  111. 		<dependency>
  112. 			<groupId>com.baomidou</groupId>
  113. 			<artifactId>mybatis-plus-boot-starter</artifactId>
  114. 			<version>3.4.0</version>
  115. 		</dependency>
  116.  
  117. 		<!--MyBatis的PageHelper插件-->
  118. 		<dependency>
  119. 			<groupId>com.github.pagehelper</groupId>
  120. 			<artifactId>pagehelper</artifactId>
  121. 			<version>${pagehelper.version}</version>
  122. 		</dependency>
  123.  
  124. 		<dependency>
  125. 			<groupId>com.baomidou</groupId>
  126. 			<artifactId>dynamic-datasource-spring-boot-starter</artifactId>
  127. 			<version>3.1.0</version>
  128. 		</dependency>
  129.  
  130. 		<dependency>
  131. 			<groupId>org.freemarker</groupId>
  132. 			<artifactId>freemarker</artifactId>
  133. 			<version>2.3.28</version>
  134. 		</dependency>
  135.  
  136.  
  137. 		<dependency>
  138. 			<groupId>com.github.davidfantasy</groupId>
  139. 			<artifactId>mybatis-plus-generator-ui</artifactId>
  140. 			<version>1.4.5</version>
  141. 			<scope>test</scope>
  142. 		</dependency>
  143.  
  144. 		<dependency>
  145. 			<groupId>com.alibaba</groupId>
  146. 			<artifactId>fastjson</artifactId>
  147. 			<version>1.2.47</version>
  148. 		</dependency>
  149.  
  150.  
  151. 		<dependency>
  152. 			<groupId>org.springframework.boot</groupId>
  153. 			<artifactId>spring-boot-devtools</artifactId>
  154. 			<optional>true</optional>
  155. 			<scope>runtime</scope>
  156. 		</dependency>
  157.  
  158.  
  159. 		<!-- swagger -->
  160. 		<dependency>
  161. 			<groupId>io.springfox</groupId>
  162. 			<artifactId>springfox-swagger2</artifactId>
  163. 			<version>2.9.2</version>
  164. 		</dependency>
  165. 		<dependency>
  166. 			<groupId>io.springfox</groupId>
  167. 			<artifactId>springfox-swagger-ui</artifactId>
  168. 			<version>2.9.2</version>
  169. 		</dependency>
  170.  
  171. 		<!-- 使用httpclient需要的maven依赖  -->
  172. 		<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpcore -->
  173. 		<dependency>
  174. 			<groupId>org.apache.httpcomponents</groupId>
  175. 			<artifactId>httpcore</artifactId>
  176. 			<version>4.4.9</version>
  177. 		</dependency>
  178.  
  179. 		<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
  180. 		<dependency>
  181. 			<groupId>org.apache.httpcomponents</groupId>
  182. 			<artifactId>httpclient</artifactId>
  183. 			<version>4.5.6</version>
  184. 		</dependency>
  185. 		<!-- logging日志 -->
  186. 		<dependency>
  187. 			<groupId>org.springframework.boot</groupId>
  188. 			<artifactId>spring-boot-starter-logging</artifactId>
  189. 		</dependency>
  190.  
  191. 		<!--添加servlet-api的依赖,用来打war包  -->
  192. 		<dependency>
  193. 			<groupId>javax.servlet</groupId>
  194. 			<artifactId>javax.servlet-api</artifactId>
  195. 			<scope>provided</scope>
  196. 		</dependency>
  197.  
  198. 		<!-- jstl -->
  199. 		<dependency>
  200. 			<groupId>jstl</groupId>
  201. 			<artifactId>jstl</artifactId>
  202. 			<version>1.2</version>
  203. 		</dependency>
  204.  
  205. 		<!-- 引入JWT -->
  206. 		<dependency>
  207. 			<groupId>com.auth0</groupId>
  208. 			<artifactId>java-jwt</artifactId>
  209. 			<version>3.4.1</version>
  210. 		</dependency>
  211.  
  212. 		<!-- 腾讯云短信功能 -->
  213. 		<dependency>
  214. 			<groupId>com.tencentcloudapi</groupId>
  215. 			<artifactId>tencentcloud-sdk-java</artifactId>
  216. 			<version>3.1.298</version>
  217. 		</dependency>
  218.  
  219. 		<dependency>
  220. 			<groupId>com.github.qcloudsms</groupId>
  221. 			<artifactId>qcloudsms</artifactId>
  222. 			<version>1.0.6</version>
  223. 		</dependency>
  224.  
  225. 	</dependencies>
  226.  
  227. 	<build>
  228. 		<plugins>
  229. 			<plugin>
  230. 				<groupId>org.springframework.boot</groupId>
  231. 				<artifactId>spring-boot-maven-plugin</artifactId>
  232. 				<configuration>
  233. 					<fork>false</fork>
  234. 				</configuration>
  235. 			</plugin>
  236.  
  237. 		</plugins>
  238. 	</build>
  239. 	<repositories>
  240. 		<repository>
  241. 			<id>spring-milestones</id>
  242. 			<name>Spring Milestones</name>
  243. 			<url>https://repo.spring.io/milestone</url>
  244. 			<snapshots>
  245. 				<enabled>false</enabled>
  246. 			</snapshots>
  247. 		</repository>
  248. 		<repository>
  249. 			<id>spring-snapshots</id>
  250. 			<name>Spring Snapshots</name>
  251. 			<url>https://repo.spring.io/snapshot</url>
  252. 			<releases>
  253. 				<enabled>false</enabled>
  254. 			</releases>
  255. 		</repository>
  256. 	</repositories>
  257. 	<pluginRepositories>
  258. 		<pluginRepository>
  259. 			<id>spring-milestones</id>
  260. 			<name>Spring Milestones</name>
  261. 			<url>https://repo.spring.io/milestone</url>
  262. 			<snapshots>
  263. 				<enabled>false</enabled>
  264. 			</snapshots>
  265. 		</pluginRepository>
  266. 		<pluginRepository>
  267. 			<id>spring-snapshots</id>
  268. 			<name>Spring Snapshots</name>
  269. 			<url>https://repo.spring.io/snapshot</url>
  270. 			<releases>
  271. 				<enabled>false</enabled>
  272. 			</releases>
  273. 		</pluginRepository>
  274. 	</pluginRepositories>
  275.  
  276. </project>

application.properties

  1. # 使用配置文件
  2. spring.profiles.active=dev
  3.  
  4. #调试模式
  5. # 1、在application.properties文件添加 debug=true
  6. # 2、
  7. debug=true
  8.  
  9.  
  10. # Redis 配置
  11. spring.redis.database=0
  12. spring.redis.host=192.168.0.198
  13. spring.redis.port=6379
  14. spring.redis.password=123456
  15. spring.redis.timeout=6000
  16. spring.redis.jedis.pool.min-idle=20
  17. # 最大空闲数，数据库连接的最大空闲时间。超过空闲数量，数据库连接将被标记为不可用，然后被释放。设为0表示无限制
  18. spring.redis.jedis.pool.max-idle=100
  19. ##jedis的最大活跃连接数设为0表示无限制
  20. spring.redis.jedis.pool.max-active=500
  21. #最大等待时间：单位ms
  22. #jedis池没有连接对象返回时，等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。
  23. #如果超过等待时间，则直接抛出JedisConnectionException
  24. spring.redis.jedis.pool.max-wait=60000
Redis配置类: JedisConfig.java
  1. package com.microStationCom.config;
  2.  
  3. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  4. import com.fasterxml.jackson.annotation.PropertyAccessor;
  5. import com.fasterxml.jackson.databind.ObjectMapper;
  6. import org.slf4j.Logger;
  7. import org.slf4j.LoggerFactory;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.beans.factory.annotation.Value;
  10. import org.springframework.cache.annotation.CachingConfigurerSupport;
  11. import org.springframework.context.annotation.Bean;
  12. import org.springframework.context.annotation.Configuration;
  13. import org.springframework.data.redis.connection.RedisConnectionFactory;
  14. import org.springframework.data.redis.core.*;
  15. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  16. import org.springframework.data.redis.serializer.StringRedisSerializer;
  17. import org.springframework.util.StringUtils;
  18. import redis.clients.jedis.JedisPool;
  19. import redis.clients.jedis.JedisPoolConfig;
  20.  
  21.  
  22. /**
  23.  * redis配置类
  24.  */
  25. @Configuration
  26. public class JedisConfig extends CachingConfigurerSupport {
  27.  
  28.     private static Logger logger = LoggerFactory.getLogger(JedisConfig.class);
  29.  
  30.     /**
  31.      * SpringSession  需要注意的就是redis需要2.8以上版本，然后开启事件通知，在redis配置文件里面加上
  32.      * notify-keyspace-events Ex
  33.      * Keyspace notifications功能默认是关闭的（默认地，Keyspace 时间通知功能是禁用的，因为它或多或少会使用一些CPU的资源）。
  34.      * 或是使用如下命令：
  35.      * redis-cli config set notify-keyspace-events Egx
  36.      * 如果你的Redis不是你自己维护的，比如你是使用阿里云的Redis数据库，你不能够更改它的配置，那么可以使用如下方法：在applicationContext.xml中配置
  37.      * <util:constant static-field="org.springframework.session.data.redis.config.ConfigureRedisAction.NO_OP"/>
  38.      *
  39.      * @return
  40.      */
  41.  
  42.     @Value("${spring.redis.host}")
  43.     private String host;
  44.  
  45.     @Value("${spring.redis.port}")
  46.     private int port;
  47.  
  48.     @Value("${spring.redis.timeout}")
  49.     private int timeout;
  50.  
  51.     @Value("${spring.redis.jedis.pool.max-active}")
  52.     private int maxActive;
  53.  
  54.     @Value("${spring.redis.jedis.pool.max-idle}")
  55.     private int maxIdle;
  56.  
  57.     @Value("${spring.redis.jedis.pool.min-idle}")
  58.     private int minIdle;
  59.  
  60.     @Value("${spring.redis.jedis.pool.max-wait}")
  61.     private long maxWaitMillis;
  62.  
  63.     @Value("${spring.redis.password}")
  64.     private String password;
  65.  
  66.     @Bean
  67.     public JedisPool redisPoolFactory() {
  68.  
  69.         logger.info("============== JedisPool 连接池注入 开始 ===============");
  70.         JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
  71.         jedisPoolConfig.setMaxIdle(maxIdle);
  72.         jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
  73.         jedisPoolConfig.setMaxTotal(maxActive);
  74.         jedisPoolConfig.setMinIdle(minIdle);
  75.         JedisPool jedisPool = null;
  76.         if (StringUtils.isEmpty(password)) {
  77.             jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout);
  78.         } else {
  79.             jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, password);
  80.         }
  81.         logger.info("JedisPool 连接池注入成功");
  82.         logger.info("redis连接信息  地址：" + host + ":" + port + ":" + password);
  83.         logger.info("============== JedisPool 连接池注入 结束 ===============");
  84.         return jedisPool;
  85.     }
  86.  
  87.  
  88.  
  89.  
  90.     /**
  91.      * retemplate相关配置
  92.      * @param factory
  93.      * @return
  94.      */
  95.     @Bean
  96.     public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory){
  97.         StringRedisTemplate template = new StringRedisTemplate();
  98.         // 配置连接工厂
  99.         template.setConnectionFactory(factory);
  100.  
  101.         //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
  102.         Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
  103.         ObjectMapper om = new ObjectMapper();
  104.         // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
  105.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  106.         // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
  107.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  108.         jacksonSeial.setObjectMapper(om);
  109.  
  110.         // 值采用json序列化
  111.         template.setValueSerializer(new StringRedisSerializer());
  112.         //使用StringRedisSerializer来序列化和反序列化redis的key值
  113.         template.setKeySerializer(new StringRedisSerializer());
  114.         // 设置hash key 和value序列化模式
  115.         template.setHashKeySerializer(new StringRedisSerializer());
  116.         template.setHashValueSerializer(jacksonSeial);
  117.         template.afterPropertiesSet();
  118.         return template;
  119.     }
  120.  
  121.  
  122.  
  123.     @Bean
  124.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
  125.  
  126.         RedisTemplate<String, Object> template = new RedisTemplate<>();
  127.         // 配置连接工厂
  128.         template.setConnectionFactory(factory);
  129.  
  130.         //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
  131.         Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
  132.  
  133.         ObjectMapper om = new ObjectMapper();
  134.         // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
  135.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  136.         // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
  137.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  138.         jacksonSeial.setObjectMapper(om);
  139.  
  140.         // 值采用json序列化
  141.         template.setValueSerializer(new StringRedisSerializer());
  142.         //使用StringRedisSerializer来序列化和反序列化redis的key值
  143.         template.setKeySerializer(new StringRedisSerializer());
  144.  
  145.         // 设置hash key 和value序列化模式
  146.         template.setHashKeySerializer(new StringRedisSerializer());
  147.         template.setHashValueSerializer(jacksonSeial);
  148.         template.afterPropertiesSet();
  149.  
  150.         return template;
  151.     }
  152.  
  153.     /**
  154.      * 对hash类型的数据操作
  155.      *
  156.      * @param redisTemplate
  157.      * @return
  158.      */
  159.     @Bean
  160.     public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
  161.         return redisTemplate.opsForHash();
  162.     }
  163.  
  164.     /**
  165.      * 对redis字符串类型数据操作
  166.      *
  167.      * @param redisTemplate
  168.      * @return
  169.      */
  170.     @Bean
  171.     public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
  172.         return redisTemplate.opsForValue();
  173.     }
  174.  
  175.     /**
  176.      * 对链表类型的数据操作
  177.      *
  178.      * @param redisTemplate
  179.      * @return
  180.      */
  181.     @Bean
  182.     public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
  183.         return redisTemplate.opsForList();
  184.     }
  185.  
  186.     /**
  187.      * 对无序集合类型的数据操作
  188.      *
  189.      * @param redisTemplate
  190.      * @return
  191.      */
  192.     @Bean
  193.     public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
  194.         return redisTemplate.opsForSet();
  195.     }
  196.  
  197.     /**
  198.      * 对有序集合类型的数据操作
  199.      *
  200.      * @param redisTemplate
  201.      * @return
  202.      */
  203.     @Bean
  204.     public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
  205.         return redisTemplate.opsForZSet();
  206.     }
  207. }
Redis缓存工具类: RedisCacheUtils.java
  1. package com.microStationCom.util;
  2.  
  3. import org.apache.commons.lang.StringUtils;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.data.redis.core.BoundHashOperations;
  6. import org.springframework.data.redis.core.RedisTemplate;
  7. import org.springframework.data.redis.core.StringRedisTemplate;
  8. import org.springframework.stereotype.Component;
  9. import org.springframework.util.CollectionUtils;
  10.  
  11. import javax.annotation.PostConstruct;
  12. import java.util.Map;
  13. import java.util.Set;
  14. import java.util.concurrent.TimeUnit;
  15.  
  16. /**
  17.  * Redis 缓存工具类
  18.  */
  19. @Component
  20. public class RedisCacheUtils {
  21.  
  22.     @Autowired
  23.     private StringRedisTemplate stringRedisTemplate;
  24.  
  25.     @Autowired
  26.     private RedisTemplate redisTemplate;
  27.  
  28.     public static StringRedisTemplate stringRedisTemplate1;
  29.  
  30.     public static RedisTemplate redisTemplate1;
  31.  
  32.     //单位警情数据前缀
  33.     public static final String KEY_ALARM_GROUPID_PREFIX = "alarmWz:groupId_";
  34.     //redis中key的超时时间
  35.     public static final long KEY_ALARM_TIMEOUT = 12 * 60 * 60;//单位为秒，2小时（7200秒）
  36.  
  37.  
  38. //    /** redis操作模板，面向对象的模板 */
  39. //    private static StringRedisTemplate stringRedisTemplate
  40. //            = (StringRedisTemplate) SpringUtil.getBean("stringRedisTemplate");
  41. //    private static RedisTemplate<String, Object> redisTemplate
  42. //            = (RedisTemplate) SpringUtil.getBean("redisTemplate");
  43.  
  44.     /**
  45.      * 删除缓存<br>
  46.      * 根据key精确匹配删除
  47.      *
  48.      * @param key
  49.      */
  50.     @SuppressWarnings("unchecked")
  51.     public static void del(String... key) {
  52.         if (key != null && key.length > 0) {
  53.             if (key.length == 1) {
  54.                 redisTemplate1.delete(key[0]);
  55.             } else {
  56.                 redisTemplate1.delete(CollectionUtils.arrayToList(key));
  57.             }
  58.         }
  59.     }
  60.  
  61.     /**
  62.      * (根据key精确匹配删除)
  63.      * @param key
  64.      */
  65.     public static void deleteByKey(String  key) {
  66.         if (key != null) {
  67.             if (stringRedisTemplate1.delete(key) == true)
  68.             {
  69.             }else{
  70.                 redisTemplate1.delete(key);
  71.             }
  72.  
  73.         }
  74.     }
  75.  
  76.     /**
  77.      * 批量删除<br>
  78.      * （该操作会执行模糊查询，请尽量不要使用，以免影响性能或误删）
  79.      *
  80.      * @param pattern
  81.      */
  82.     public void batchDel(String... pattern) {
  83.         for (String kp : pattern) {
  84.             redisTemplate1.delete(redisTemplate1.keys(kp + "*"));
  85.         }
  86.     }
  87.  
  88.     /**
  89.      * 取得缓存（int型）
  90.      *
  91.      * @param key
  92.      * @return
  93.      */
  94.     public  Integer getInt(String key) {
  95.         String value = stringRedisTemplate1.boundValueOps(key).get();
  96.         if (StringUtils.isNotEmpty(value)) {
  97.             return Integer.valueOf(value);
  98.         }
  99.         return null;
  100.     }
  101.  
  102.     /**
  103.      * 取得缓存（字符串类型）
  104.      *
  105.      * @param key
  106.      * @return
  107.      */
  108.     public static String getStr(String key) {
  109.         return stringRedisTemplate1.boundValueOps(key).get();
  110.     }
  111.  
  112.     /**
  113.      * 取得缓存（字符串类型）
  114.      *
  115.      * @param key
  116.      * @return
  117.      */
  118.     public static String getStr(String key, boolean retain) {
  119.         String value = stringRedisTemplate1.boundValueOps(key).get();
  120.         if (!retain) {
  121.             redisTemplate1.delete(key);
  122.         }
  123.         return value;
  124.     }
  125.  
  126.     /**
  127.      * 模糊查询(根据规则) 返回 keys
  128.      * @param pattern
  129.      * @return
  130.      */
  131.     public static Set<String> searchKeys(String pattern){
  132.        return stringRedisTemplate1.keys(pattern);
  133.     }
  134.  
  135.  
  136.     /**
  137.      * 获取缓存<br>
  138.      * 注：基本数据类型(Character除外)，请直接使用get(String key, Class<T> clazz)取值
  139.      *
  140.      * @param key
  141.      * @return
  142.      */
  143.     public static Object getObj(String key) {
  144.         return redisTemplate1.boundValueOps(key).get();
  145.     }
  146.  
  147.     /**
  148.      * 获取缓存<br>
  149.      * 注：java 8种基本类型的数据请直接使用get(String key, Class<T> clazz)取值
  150.      *
  151.      * @param key
  152.      * @param retain
  153.      *            是否保留
  154.      * @return
  155.      */
  156.     public  Object getObj(String key, boolean retain) {
  157.         Object obj = redisTemplate1.boundValueOps(key).get();
  158.         if (!retain) {
  159.             redisTemplate.delete(key);
  160.         }
  161.         return obj;
  162.     }
  163.  
  164.     /**
  165.      * 获取缓存<br>
  166.      * 注：该方法暂不支持Character数据类型
  167.      *
  168.      * @param key
  169.      *            key
  170.      * @param clazz
  171.      *            类型
  172.      * @return
  173.      */
  174.     @SuppressWarnings("unchecked")
  175.     public  <T> T get(String key, Class<T> clazz) {
  176.  
  177.         return (T) redisTemplate1.boundValueOps(key).get();
  178.     }
  179.  
  180.     /**
  181.      * 获取缓存json对象<br>
  182.      *
  183.      * @param key
  184.      *            key
  185.      * @param clazz
  186.      *            类型
  187.      * @return
  188.      * @throws Exception
  190.     @SuppressWarnings("unchecked")
  191.     public  <T> T getJson(String key, Class<T> clazz) throws Exception {
  192.         String jsonStr=null;
  193.         jsonStr=stringRedisTemplate.boundValueOps(key).get();
  194.         if(jsonStr==null){
  195.             return null;
  196.         }else{
  197.             return (T) JsonUtil.jsonToBean(jsonStr, clazz);
  198.         }
  199.     } */
  200.  
  201.     /**
  202.      * 将value对象写入缓存
  203.      *
  204.      * @param key
  205.      * @param value
  206.      * @param time
  207.      *            失效时间(秒)
  208.      */
  209.     public static void set(String key, Object value, Long time) {
  210.         if (value.getClass().equals(String.class)) {
  211.             stringRedisTemplate1.opsForValue().set(key, value.toString());
  212.         } else if (value.getClass().equals(Integer.class)) {
  213.             stringRedisTemplate1.opsForValue().set(key, value.toString());
  214.         } else if (value.getClass().equals(Double.class)) {
  215.             stringRedisTemplate1.opsForValue().set(key, value.toString());
  216.         } else if (value.getClass().equals(Float.class)) {
  217.             stringRedisTemplate1.opsForValue().set(key, value.toString());
  218.         } else if (value.getClass().equals(Short.class)) {
  219.             stringRedisTemplate1.opsForValue().set(key, value.toString());
  220.         } else if (value.getClass().equals(Long.class)) {
  221.             stringRedisTemplate1.opsForValue().set(key, value.toString());
  222.         } else if (value.getClass().equals(Boolean.class)) {
  223.             stringRedisTemplate1.opsForValue().set(key, value.toString());
  224.         }
  225.         else {
  226.             redisTemplate1.opsForValue().set(key, value);
  227.         }
  228.         if (time != null && time > 0) {
  229.             redisTemplate1.expire(key, time, TimeUnit.SECONDS);
  230.             stringRedisTemplate1.expire(key, time, TimeUnit.SECONDS);
  231.         }
  232.     }
  233.  
  234.     /**
  235.      * 将value对象以JSON格式写入缓存
  236.      *
  237.      * @param key
  238.      * @param value
  239.      * @param time
  240.      *            失效时间(秒)
  242.     public  void setJson(String key, Object value, Long time) {
  243.         stringRedisTemplate.opsForValue().set(key, JsonUtil.toJsonString(value));
  244.         if (time!=null&&time > 0) {
  245.             stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
  246.         }
  247.     }
  248.      */
  249.  
  250.     /**
  251.      * 更新key对象field的值
  252.      *
  253.      * @param key
  254.      *            缓存key
  255.      * @param field
  256.      *            缓存对象field
  257.      * @param value
  258.      *            缓存对象field值
  260.     public  void setJsonField(String key, String field, String value) {
  261.         JSONObject obj = JSON.parseObject(stringRedisTemplate.boundValueOps(key).get());
  262.         obj.put(field, value);
  263.         stringRedisTemplate.opsForValue().set(key, obj.toJSONString());
  264.     }
  265.      */
  266.  
  267.     /**
  268.      * 递减操作
  269.      *
  270.      * @param key
  271.      * @param by
  272.      * @return
  273.      */
  274.     public  double decr(String key, double by) {
  275.         return redisTemplate1.opsForValue().increment(key, -by);
  276.     }
  277.  
  278.     /**
  279.      * 递增操作
  280.      *
  281.      * @param key
  282.      * @param by
  283.      * @return
  284.      */
  285.     public  double incr(String key, double by) {
  286.         return redisTemplate1.opsForValue().increment(key, by);
  287.     }
  288.  
  289.     /**
  290.      * 获取double类型值
  291.      *
  292.      * @param key
  293.      * @return
  294.      */
  295.     public  double getDouble(String key) {
  296.         String value = stringRedisTemplate.boundValueOps(key).get();
  297.         if (StringUtils.isNotBlank(value)) {
  298.             return Double.valueOf(value);
  299.         }
  300.         return 0d;
  301.     }
  302.  
  303.     /**
  304.      * 设置double类型值
  305.      *
  306.      * @param key
  307.      * @param value
  308.      * @param time
  309.      *            失效时间(秒)
  310.      */
  311.     public  void setDouble(String key, double value, Long time) {
  312.         stringRedisTemplate1.opsForValue().set(key, String.valueOf(value));
  313.         if (time!=null&&time > 0) {
  314.             stringRedisTemplate1.expire(key, time, TimeUnit.SECONDS);
  315.         }
  316.     }
  317.  
  318.     /**
  319.      * 设置double类型值
  320.      *
  321.      * @param key
  322.      * @param value
  323.      * @param time
  324.      *            失效时间(秒)
  325.      */
  326.     public  void setInt(String key, int value, Long time) {
  327.         stringRedisTemplate1.opsForValue().set(key, String.valueOf(value));
  328.         if (time!=null&&time > 0) {
  329.             stringRedisTemplate1.expire(key, time, TimeUnit.SECONDS);
  330.         }
  331.     }
  332.  
  333.     /**
  334.      * 将map写入缓存
  335.      *
  336.      * @param key
  337.      * @param map
  338.      * @param time
  339.      *            失效时间(秒)
  340.      */
  341.     public  <T> void setMap(String key, Map<String, T> map, Long time) {
  342.         redisTemplate1.opsForHash().putAll(key, map);
  343.     }
  344.  
  345.     /**
  346.      * 将map写入缓存
  347.      *
  348.      * @param key
  349.      * @param map
  350.      * @param time
  351.      *            失效时间(秒)
  353.     @SuppressWarnings("unchecked")
  354.     public  <T> void setMap(String key, T obj, Long time) {
  355.         Map<String, String> map = (Map<String, String>)JsonUtil.parseObject(obj, Map.class);
  356.         redisTemplate.opsForHash().putAll(key, map);
  357.     }
  358.      */
  359.  
  360.     /**
  361.      * 向key对应的map中添加缓存对象
  362.      *
  363.      * @param key
  364.      * @param map
  365.      */
  366.     public  <T> void addMap(String key, Map<String, T> map) {
  367.         redisTemplate1.opsForHash().putAll(key, map);
  368.     }
  369.  
  370.     /**
  371.      * 向key对应的map中添加缓存对象
  372.      *
  373.      * @param key
  374.      *            cache对象key
  375.      * @param field
  376.      *            map对应的key
  377.      * @param value
  378.      *            值
  379.      */
  380.     public  void addMap(String key, String field, String value) {
  381.         redisTemplate1.opsForHash().put(key, field, value);
  382.     }
  383.  
  384.     /**
  385.      * 向key对应的map中添加缓存对象
  386.      *
  387.      * @param key
  388.      *            cache对象key
  389.      * @param field
  390.      *            map对应的key
  391.      * @param obj
  392.      *            对象
  393.      */
  394.     public  <T> void addMap(String key, String field, T obj) {
  395.         redisTemplate1.opsForHash().put(key, field, obj);
  396.     }
  397.  
  398.     /**
  399.      * 获取map缓存
  400.      *
  401.      * @param key
  402.      * @param clazz
  403.      * @return
  405.     public  <T> Map<String, T> mget(String key, Class<T> clazz) {
  406.         BoundHashOperations<String, String, T> boundHashOperations = redisTemplate.boundHashOps(key);
  407.         return boundHashOperations.entries();
  408.     }*/
  409.  
  410.     /**
  411.      * 获取map缓存中的某个对象
  412.      *
  413.      * @param key
  414.      * @param field
  415.      * @param clazz
  416.      * @return
  417.      */
  418.     @SuppressWarnings("unchecked")
  419.     public  <T> T getMapField(String key, String field, Class<T> clazz) {
  420.         return (T) redisTemplate1.boundHashOps(key).get(field);
  421.     }
  422.  
  423.     /**
  424.      * 获取map缓存
  425.      *
  426.      * @param key
  427.      * @param clazz
  428.      * @return
  430.     public  <T> T getMap(String key, Class<T> clazz) {
  431.         BoundHashOperations<String, String, String> boundHashOperations = redisTemplate.boundHashOps(key);
  432.         Map<String, String> map = boundHashOperations.entries();
  433.         return JsonUtil.parseObject(map, clazz);
  434.     } */
  435.  
  436.     /**
  437.      * 删除map中的某个对象
  438.      *
  439.      * @author lh
  440.      * @date 2016年8月10日
  441.      * @param key
  442.      *            map对应的key
  443.      * @param field
  444.      *            map中该对象的key
  445.      */
  446.     public void delMapField(String key, String... field) {
  447.         BoundHashOperations<String, String, ?> boundHashOperations = redisTemplate1.boundHashOps(key);
  448.         boundHashOperations.delete(field);
  449.     }
  450.  
  451.     /**
  452.      * 指定缓存的失效时间
  453.      *
  454.      * @author FangJun
  455.      * @date 2016年8月14日
  456.      * @param key
  457.      *            缓存KEY
  458.      * @param time
  459.      *            失效时间(秒)
  460.      */
  461.     public  void expire(String key, Long time) {
  462.         if (time!=null&&time > 0) {
  463.             redisTemplate1.expire(key, time, TimeUnit.SECONDS);
  464.         }
  465.     }
  466.  
  467.     /**
  468.      * 添加set
  469.      *
  470.      * @param key
  471.      * @param value
  472.      */
  473.     public  void sadd(String key, String... value) {
  474.         redisTemplate1.boundSetOps(key).add(value);
  475.     }
  476.  
  477.     /**
  478.      * 删除set集合中的对象
  479.      *
  480.      * @param key
  481.      * @param value
  482.      */
  483.     public  void srem(String key, String... value) {
  484.         redisTemplate1.boundSetOps(key).remove(value);
  485.     }
  486.  
  487.     /**
  488.      * set重命名
  489.      *
  490.      * @param oldkey
  491.      * @param newkey
  492.      */
  493.     public  void srename(String oldkey, String newkey) {
  494.         redisTemplate1.boundSetOps(oldkey).rename(newkey);
  495.     }
  496.  
  497.  
  498.  
  499.  
  500.     /**
  501.      * 短信缓存
  502.      *
  503.      * @author fxl
  504.      * @date 2016年9月11日
  505.      * @param key
  506.      * @param value
  507.      * @param time
  509.     public  void setIntForPhone(String key, Object value, int time) {
  510.         stringRedisTemplate.opsForValue().set(key, JsonUtil.toJsonString(value));
  511.         if (time > 0) {
  512.             stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
  513.         }
  514.     }
  515.      */
  516.  
  517.     /**
  518.      * 模糊查询keys
  519.      *
  520.      * @param pattern
  521.      * @return
  522.      */
  523.     public static Set<String> keys(String pattern) {
  524.  
  525.         return redisTemplate1.keys(pattern);
  526.     }
  527.  
  528.     /**
  529.      *
  530.      * @Description (检查key是否存在，返回boolean值 )
  531.      * @author feizhou
  532.      * @Date 2018年5月29日下午5:37:40
  533.      * @version 1.0.0
  534.      * @param key
  535.      * @return
  536.      */
  537.     public  Boolean   ishasKey(String key) {
  538.         return stringRedisTemplate.hasKey(key);
  539.     }
  540.  
  541.     @PostConstruct
  542.     public StringRedisTemplate getStringRedisTemplate() {
  543.         stringRedisTemplate1 = stringRedisTemplate;
  544.         System.out.println("获取缓存： getStringRedisTemplate ... " + stringRedisTemplate.toString());
  545.         return stringRedisTemplate1;
  546.     }
  547.  
  548.     public void setStringRedisTemplate(StringRedisTemplate stringRedisTemplate) {
  549.         System.out.println("设置缓存： setStringRedisTemplate ... " + stringRedisTemplate.toString());
  550.         this.stringRedisTemplate = stringRedisTemplate;
  551.     }
  552.  
  553.     @PostConstruct
  554.     public RedisTemplate<String, Object> getRedisTemplate() {
  555.         redisTemplate1 = redisTemplate;
  556.         System.out.println("获取缓存： getStringRedisTemplate ... " + stringRedisTemplate.toString());
  557.         return redisTemplate1;
  558.     }
  559.  
  560.     public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
  561.         System.out.println("设置缓存： setRedisTemplate ... " + redisTemplate.toString());
  562.         this.redisTemplate = redisTemplate;
  563.     }
  564. }

//操作redis,直接在控制器类或工具类中，使用 RedisCacheUtils.java类并调用相关的静态方法。
  1. //从redis缓存中取警情信息，条件：需要unitUid
  2.             //操作redis
  3.             String key = RedisCacheUtils.KEY_ALARM_GROUPID_PREFIX + unitUid;
  4.             String alarmDataStr = RedisCacheUtils.getStr(key);
  5.             if (!StringUtils.isEmpty(alarmDataStr)){
  6.                 logger.info("警情信息确认（小程序）：alarmId-{}, deptId-{}, groupNo-{}, unitUid-{} ", alarmId , deptId , groupNo , unitUid);
  7.  
  8.                 List<AlarmData> list = JSONArray.parseArray(alarmDataStr , AlarmData.class);
  9.                 //List<AlarmData> list = JSONObject.parseObject(alarmDataStr , List.class);
  10.                 if (null != list && list.size() > 0){
  11.  
  12.                     //更新警情车辆调派记录(小程序)：确认时间    2022-08-12
  13.                     AlarmData alarmData = list.get(0);
  14.                     int saveFlag = alarmFlowbakService.saveAlarmCarFlowQrsj(alarmData.getUpid() , unitUid);
  15.                     logger.info("警情信息确认（小程序）：更新调派车辆记录确认时间 , 更新标记:{} , upid:{} , unitUid:{} ...  " , saveFlag , alarmData.getUpid() , unitUid );
  16.                     RedisCacheUtils.deleteByKey(key);
  17.                     logger.info("警情信息确认（小程序）：从 Redis 缓存中清除警情信息 ... {} " , alarmDataStr);
  18.                 }else{
  19.                     logger.error("警情信息确认（小程序）：从 Redis 缓存中读取警情信息出现错误！！！ {} " , alarmDataStr);
  20.                     return JsonUtils.JsonException("确认警情信息出现错误，请联系管理员");
  21.                 }
  22.             }

其他资料

SpringBoot整合Redisicon-default.png?t=M85Bhttps://blog.csdn.net/hello_list/article/details/124893755Jedis连接工具 和 SpringBoot整合Redisicon-default.png?t=M85Bhttps://www.cnblogs.com/zxhbk/p/13054709.html

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/152198
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号