• Redis在SpringBoot项目中使用

    完整版配置（pom.xml）

    1. "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.0modelVersion>
    5. 	<parent>
    6. 		<groupId>org.springframework.bootgroupId>
    7. 		<artifactId>spring-boot-starter-parentartifactId>
    8. 		<version>2.1.8.RELEASEversion>
    9. 		<relativePath/> 
    10. 	parent>
    11. 	<groupId>com.microStationComgroupId>
    12. 	<artifactId>WebApiartifactId>
    13. 	<version>0.0.1-SNAPSHOTversion>
    14. 	<name>WebApiname>
    15. 	
    16.  
    18. 	
    19.     <packaging>jarpackaging>
    20. 	<description>microStationCom WebApidescription>
    21. 	<properties>
    22. 		<java.version>1.8java.version>
    23. 		<tencent.qcloudsms.version>3.1.298tencent.qcloudsms.version>
    24. 		<pagehelper.version>5.0.3pagehelper.version>
    25. 	properties>
    26. 	<dependencies>
    27. 		<dependency>
    28. 			<groupId>org.springframework.bootgroupId>
    29. 			<artifactId>spring-boot-starter-webartifactId>
    30. 			
    31. 		dependency>
    32.  
    33. 		
    34. 		<dependency>
    35. 			<groupId>org.springframework.bootgroupId>
    36. 			<artifactId>spring-boot-starter-data-redisartifactId>
    37. 			
    38. 			<exclusions>
    39. 				<exclusion>
    40. 					<groupId>io.lettucegroupId>
    41. 					<artifactId>lettuce-coreartifactId>
    42. 				exclusion>
    43. 			exclusions>
    44. 		dependency>
    45.  
    46. 		
    47. 		<dependency>
    48. 			<groupId>redis.clientsgroupId>
    49. 			<artifactId>jedisartifactId>
    50. 		dependency>
    51. 		<dependency>
    52. 			<groupId>org.apache.commonsgroupId>
    53. 			<artifactId>commons-pool2artifactId>
    54. 		dependency>
    55. 		<dependency>
    56. 			<groupId>commons-langgroupId>
    57. 			<artifactId>commons-langartifactId>
    58. 			<version>2.3version>
    59. 		dependency>
    60.  
    61. 		<dependency>
    62. 			<groupId>com.microsoft.sqlservergroupId>
    63. 			<artifactId>sqljdbc4artifactId>
    64. 			<version>4.0version>
    65. 			<scope>runtimescope>
    66. 		dependency>
    67.  
    68. 		<dependency>
    69. 			<groupId>com.alibabagroupId>
    70. 			<artifactId>druid-spring-boot-starterartifactId>
    71. 			<version>1.1.10version>
    72. 		dependency>
    73.  
    74. 		<dependency>
    75. 			<groupId>ch.qos.logbackgroupId>
    76. 			<artifactId>logback-coreartifactId>
    77. 		dependency>
    78.  
    79. 		<dependency>
    80. 			<groupId>commons-codecgroupId>
    81. 			<artifactId>commons-codecartifactId>
    82. 			<version>1.9version>
    83. 		dependency>
    84.  
    85. 		<dependency>
    86. 			<groupId>org.springframework.bootgroupId>
    87. 			<artifactId>spring-boot-starter-testartifactId>
    88. 			<scope>testscope>
    89. 		dependency>
    90.  
    91. 		<dependency>
    92. 			<groupId>org.projectlombokgroupId>
    93. 			<artifactId>lombokartifactId>
    94. 			<optional>trueoptional>
    95. 		dependency>
    96. 		
    97. 		
    98. 		<dependency>
    99. 			<groupId>com.baomidougroupId>
    100. 			<artifactId>mybatis-plus-generatorartifactId>
    101. 			<version>3.4.0version>
    102. 		dependency>
    103.  
    104. 		<dependency>
    105. 			<groupId>com.baomidougroupId>
    106. 			<artifactId>mybatis-plus-boot-starterartifactId>
    107. 			<version>3.4.0version>
    108. 		dependency>
    109.  
    110. 		
    111. 		<dependency>
    112. 			<groupId>com.github.pagehelpergroupId>
    113. 			<artifactId>pagehelperartifactId>
    114. 			<version>${pagehelper.version}version>
    115. 		dependency>
    116.  
    117. 		<dependency>
    118. 			<groupId>com.baomidougroupId>
    119. 			<artifactId>dynamic-datasource-spring-boot-starterartifactId>
    120. 			<version>3.1.0version>
    121. 		dependency>
    122.  
    123. 		<dependency>
    124. 			<groupId>org.freemarkergroupId>
    125. 			<artifactId>freemarkerartifactId>
    126. 			<version>2.3.28version>
    127. 		dependency>
    128.  
    129.  
    130. 		<dependency>
    131. 			<groupId>com.github.davidfantasygroupId>
    132. 			<artifactId>mybatis-plus-generator-uiartifactId>
    133. 			<version>1.4.5version>
    134. 			<scope>testscope>
    135. 		dependency>
    136.  
    137. 		<dependency>
    138. 			<groupId>com.alibabagroupId>
    139. 			<artifactId>fastjsonartifactId>
    140. 			<version>1.2.47version>
    141. 		dependency>
    142.  
    143.  
    144. 		<dependency>
    145. 			<groupId>org.springframework.bootgroupId>
    146. 			<artifactId>spring-boot-devtoolsartifactId>
    147. 			<optional>trueoptional>
    148. 			<scope>runtimescope>
    149. 		dependency>
    150.  
    151.  
    152. 		
    153. 		<dependency>
    154. 			<groupId>io.springfoxgroupId>
    155. 			<artifactId>springfox-swagger2artifactId>
    156. 			<version>2.9.2version>
    157. 		dependency>
    158. 		<dependency>
    159. 			<groupId>io.springfoxgroupId>
    160. 			<artifactId>springfox-swagger-uiartifactId>
    161. 			<version>2.9.2version>
    162. 		dependency>
    163.  
    164. 		
    165. 		
    166. 		<dependency>
    167. 			<groupId>org.apache.httpcomponentsgroupId>
    168. 			<artifactId>httpcoreartifactId>
    169. 			<version>4.4.9version>
    170. 		dependency>
    171.  
    172. 		
    173. 		<dependency>
    174. 			<groupId>org.apache.httpcomponentsgroupId>
    175. 			<artifactId>httpclientartifactId>
    176. 			<version>4.5.6version>
    177. 		dependency>
    178. 		
    179. 		<dependency>
    180. 			<groupId>org.springframework.bootgroupId>
    181. 			<artifactId>spring-boot-starter-loggingartifactId>
    182. 		dependency>
    183.  
    184. 		
    185. 		<dependency>
    186. 			<groupId>javax.servletgroupId>
    187. 			<artifactId>javax.servlet-apiartifactId>
    188. 			<scope>providedscope>
    189. 		dependency>
    190.  
    191. 		
    192. 		<dependency>
    193. 			<groupId>jstlgroupId>
    194. 			<artifactId>jstlartifactId>
    195. 			<version>1.2version>
    196. 		dependency>
    197.  
    198. 		
    199. 		<dependency>
    200. 			<groupId>com.auth0groupId>
    201. 			<artifactId>java-jwtartifactId>
    202. 			<version>3.4.1version>
    203. 		dependency>
    204.  
    205. 		
    206. 		<dependency>
    207. 			<groupId>com.tencentcloudapigroupId>
    208. 			<artifactId>tencentcloud-sdk-javaartifactId>
    209. 			<version>3.1.298version>
    210. 		dependency>
    211.  
    212. 		<dependency>
    213. 			<groupId>com.github.qcloudsmsgroupId>
    214. 			<artifactId>qcloudsmsartifactId>
    215. 			<version>1.0.6version>
    216. 		dependency>
    217.  
    218. 	dependencies>
    219.  
    220. 	<build>
    221. 		<plugins>
    222. 			<plugin>
    223. 				<groupId>org.springframework.bootgroupId>
    224. 				<artifactId>spring-boot-maven-pluginartifactId>
    225. 				<configuration>
    226. 					<fork>falsefork>
    227. 				configuration>
    228. 			plugin>
    229.  
    230. 		plugins>
    231. 	build>
    232. 	<repositories>
    233. 		<repository>
    234. 			<id>spring-milestonesid>
    235. 			<name>Spring Milestonesname>
    236. 			<url>https://repo.spring.io/milestoneurl>
    237. 			<snapshots>
    238. 				<enabled>falseenabled>
    239. 			snapshots>
    240. 		repository>
    241. 		<repository>
    242. 			<id>spring-snapshotsid>
    243. 			<name>Spring Snapshotsname>
    244. 			<url>https://repo.spring.io/snapshoturl>
    245. 			<releases>
    246. 				<enabled>falseenabled>
    247. 			releases>
    248. 		repository>
    249. 	repositories>
    250. 	<pluginRepositories>
    251. 		<pluginRepository>
    252. 			<id>spring-milestonesid>
    253. 			<name>Spring Milestonesname>
    254. 			<url>https://repo.spring.io/milestoneurl>
    255. 			<snapshots>
    256. 				<enabled>falseenabled>
    257. 			snapshots>
    258. 		pluginRepository>
    259. 		<pluginRepository>
    260. 			<id>spring-snapshotsid>
    261. 			<name>Spring Snapshotsname>
    262. 			<url>https://repo.spring.io/snapshoturl>
    263. 			<releases>
    264. 				<enabled>falseenabled>
    265. 			releases>
    266. 		pluginRepository>
    267. 	pluginRepositories>
    268.  
    269. 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.      * 
    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 redisTemplate(RedisConnectionFactory factory) {
    125.  
    126.         RedisTemplate 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 hashOperations(RedisTemplate redisTemplate) {
    161.         return redisTemplate.opsForHash();
    162.     }
    163.  
    164.     /**
    165.      * 对redis字符串类型数据操作
    166.      *
    167.      * @param redisTemplate
    168.      * @return
    169.      */
    170.     @Bean
    171.     public ValueOperations valueOperations(RedisTemplate redisTemplate) {
    172.         return redisTemplate.opsForValue();
    173.     }
    174.  
    175.     /**
    176.      * 对链表类型的数据操作
    177.      *
    178.      * @param redisTemplate
    179.      * @return
    180.      */
    181.     @Bean
    182.     public ListOperations listOperations(RedisTemplate redisTemplate) {
    183.         return redisTemplate.opsForList();
    184.     }
    185.  
    186.     /**
    187.      * 对无序集合类型的数据操作
    188.      *
    189.      * @param redisTemplate
    190.      * @return
    191.      */
    192.     @Bean
    193.     public SetOperations setOperations(RedisTemplate redisTemplate) {
    194.         return redisTemplate.opsForSet();
    195.     }
    196.  
    197.     /**
    198.      * 对有序集合类型的数据操作
    199.      *
    200.      * @param redisTemplate
    201.      * @return
    202.      */
    203.     @Bean
    204.     public ZSetOperations zSetOperations(RedisTemplate 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 redisTemplate
    42. //            = (RedisTemplate) SpringUtil.getBean("redisTemplate");
    43.  
    44.     /**
    45.      * 删除缓存
    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.      * 批量删除
    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 searchKeys(String pattern){
    132.        return stringRedisTemplate1.keys(pattern);
    133.     }
    134.  
    135.  
    136.     /**
    137.      * 获取缓存
    138.      * 注：基本数据类型(Character除外)，请直接使用get(String key, Class 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.      * 获取缓存
    149.      * 注：java 8种基本类型的数据请直接使用get(String key, Class 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.      * 获取缓存
    166.      * 注：该方法暂不支持Character数据类型
    167.      *
    168.      * @param key
    169.      *            key
    170.      * @param clazz
    171.      *            类型
    172.      * @return
    173.      */
    174.     @SuppressWarnings("unchecked")
    175.     public   T get(String key, Class clazz) {
    176.  
    177.         return (T) redisTemplate1.boundValueOps(key).get();
    178.     }
    179.  
    180.     /**
    181.      * 获取缓存json对象
    182.      *
    183.      * @param key
    184.      *            key
    185.      * @param clazz
    186.      *            类型
    187.      * @return
    188.      * @throws Exception
    190.     @SuppressWarnings("unchecked")
    191.     public   T getJson(String key, Class 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   void setMap(String key, Map 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   void setMap(String key, T obj, Long time) {
    355.         Map map = (Map)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   void addMap(String key, Map 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   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   Map mget(String key, Class clazz) {
    406.         BoundHashOperations 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 getMapField(String key, String field, Class 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 getMap(String key, Class clazz) {
    431.         BoundHashOperations boundHashOperations = redisTemplate.boundHashOps(key);
    432.         Map 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 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 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 getRedisTemplate() {
    555.         redisTemplate1 = redisTemplate;
    556.         System.out.println("获取缓存： getStringRedisTemplate ... " + stringRedisTemplate.toString());
    557.         return redisTemplate1;
    558.     }
    559.  
    560.     public void setRedisTemplate(RedisTemplate 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 list = JSONArray.parseArray(alarmDataStr , AlarmData.class);
    9.                 //List 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

  • 相关阅读:
    工程管理系统源码之全面+高效的工程项目管理软件
    从零实现 promise 的 class 和 function 版本
    全国双非院校考研信息汇总整理 Part.3
    在vue3框架中使用vant的input组件安卓端闪退的问题
    MySQL索引详解
    go操作Kfaka
    电脑系统Windows11安全中心内存完整性打开不了怎么办
    vue 使用this.$set设置对象属性值时，不更新试图
    如何基于WPF写一款数据库文档管理工具（二）
    高频数据分析：使用数据透视
  • 原文地址：https://blog.csdn.net/zgphacker2010/article/details/127138048