1.RedisUtils.java
1 import org.springframework.data.redis.core.BoundListOperations; 2 import org.springframework.data.redis.core.RedisTemplate; 3 import org.springframework.stereotype.Component; 4 import org.springframework.util.CollectionUtils; 5 6 import javax.annotation.Resource; 7 import java.util.List; 8 import java.util.Map; 9 import java.util.Set; 10 import java.util.concurrent.TimeUnit; 11 12 /** 13 * redisTemplate封装 14 */ 15 @Component 16 public class RedisUtil { 17 18 @Resource 19 private RedisTemplate<String, Object> redisTemplate; 20 21 public RedisUtil(RedisTemplate<String, Object> redisTemplate) { 22 this.redisTemplate = redisTemplate; 23 } 24 25 /** 26 * 指定缓存失效时间 27 * @param key 键 28 * @param time 时间(秒) 29 * @return 30 */ 31 public boolean expire(String key,long time){ 32 try { 33 if(time>0){ 34 redisTemplate.expire(key, time, TimeUnit.SECONDS); 35 } 36 return true; 37 } catch (Exception e) { 38 e.printStackTrace(); 39 return false; 40 } 41 } 42 43 /** 44 * 根据key 获取过期时间 45 * @param key 键 不能为null 46 * @return 时间(秒) 返回0代表为永久有效 47 */ 48 public long getExpire(String key){ 49 return redisTemplate.getExpire(key,TimeUnit.SECONDS); 50 } 51 52 /** 53 * 判断key是否存在 54 * @param key 键 55 * @return true 存在 false不存在 56 */ 57 public boolean hasKey(String key){ 58 try { 59 return redisTemplate.hasKey(key); 60 } catch (Exception e) { 61 e.printStackTrace(); 62 return false; 63 } 64 } 65 66 /** 67 * 删除缓存 68 * @param key 可以传一个值 或多个 69 */ 70 @SuppressWarnings("unchecked") 71 public void del(String ... key){ 72 if(key!=null&&key.length>0){ 73 if(key.length==1){ 74 redisTemplate.delete(key[0]); 75 }else{ 76 redisTemplate.delete(CollectionUtils.arrayToList(key)); 77 } 78 } 79 } 80 81 /** 82 * 普通缓存获取 83 * @param key 键 84 * @return 值 85 */ 86 public Object get(String key){ 87 return key==null?null:redisTemplate.opsForValue().get(key); 88 } 89 90 /** 91 * 普通缓存放入 92 * @param key 键 93 * @param value 值 94 * @return true成功 false失败 95 */ 96 public boolean set(String key,Object value) { 97 try { 98 redisTemplate.opsForValue().set(key, value); 99 return true; 100 } catch (Exception e) { 101 e.printStackTrace(); 102 return false; 103 } 104 } 105 106 /** 107 * 普通缓存放入并设置时间 108 * @param key 键 109 * @param value 值 110 * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期 111 * @return true成功 false 失败 112 */ 113 public boolean set(String key,Object value,long time){ 114 try { 115 if(time>0){ 116 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS); 117 }else{ 118 set(key, value); 119 } 120 return true; 121 } catch (Exception e) { 122 e.printStackTrace(); 123 return false; 124 } 125 } 126 127 /** 128 * 递增 129 * @param key 键 130 * @param delta 要增加几(大于0) 131 * @return 132 */ 133 public long incr(String key, long delta){ 134 if(delta<0){ 135 throw new RuntimeException("递增因子必须大于0"); 136 } 137 return redisTemplate.opsForValue().increment(key, delta); 138 } 139 140 /** 141 * 递减 142 * @param key 键 143 * @param delta 要减少几(小于0) 144 * @return 145 */ 146 public long decr(String key, long delta){ 147 if(delta<0){ 148 throw new RuntimeException("递减因子必须大于0"); 149 } 150 return redisTemplate.opsForValue().increment(key, -delta); 151 } 152 153 /** 154 * HashGet 155 * @param key 键 不能为null 156 * @param item 项 不能为null 157 * @return 值 158 */ 159 public Object hget(String key,String item){ 160 return redisTemplate.opsForHash().get(key, item); 161 } 162 163 /** 164 * 获取hashKey对应的所有键值 165 * @param key 键 166 * @return 对应的多个键值 167 */ 168 public Map<Object,Object> hmget(String key){ 169 return redisTemplate.opsForHash().entries(key); 170 } 171 172 /** 173 * HashSet 174 * @param key 键 175 * @param map 对应多个键值 176 * @return true 成功 false 失败 177 */ 178 public boolean hmset(String key, Map<String,Object> map){ 179 try { 180 redisTemplate.opsForHash().putAll(key, map); 181 return true; 182 } catch (Exception e) { 183 e.printStackTrace(); 184 return false; 185 } 186 } 187 188 /** 189 * HashSet 并设置时间 190 * @param key 键 191 * @param map 对应多个键值 192 * @param time 时间(秒) 193 * @return true成功 false失败 194 */ 195 public boolean hmset(String key, Map<String,Object> map, long time){ 196 try { 197 redisTemplate.opsForHash().putAll(key, map); 198 if(time>0){ 199 expire(key, time); 200 } 201 return true; 202 } catch (Exception e) { 203 e.printStackTrace(); 204 return false; 205 } 206 } 207 208 /** 209 * 向一张hash表中放入数据,如果不存在将创建 210 * @param key 键 211 * @param item 项 212 * @param value 值 213 * @return true 成功 false失败 214 */ 215 public boolean hset(String key,String item,Object value) { 216 try { 217 redisTemplate.opsForHash().put(key, item, value); 218 return true; 219 } catch (Exception e) { 220 e.printStackTrace(); 221 return false; 222 } 223 } 224 225 /** 226 * 向一张hash表中放入数据,如果不存在将创建 227 * @param key 键 228 * @param item 项 229 * @param value 值 230 * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间 231 * @return true 成功 false失败 232 */ 233 public boolean hset(String key,String item,Object value,long time) { 234 try { 235 redisTemplate.opsForHash().put(key, item, value); 236 if(time>0){ 237 expire(key, time); 238 } 239 return true; 240 } catch (Exception e) { 241 e.printStackTrace(); 242 return false; 243 } 244 } 245 246 /** 247 * 删除hash表中的值 248 * @param key 键 不能为null 249 * @param item 项 可以使多个 不能为null 250 */ 251 public void hdel(String key, Object... item){ 252 redisTemplate.opsForHash().delete(key,item); 253 } 254 255 /** 256 * 判断hash表中是否有该项的值 257 * @param key 键 不能为null 258 * @param item 项 不能为null 259 * @return true 存在 false不存在 260 */ 261 public boolean hHasKey(String key, String item){ 262 return redisTemplate.opsForHash().hasKey(key, item); 263 } 264 265 /** 266 * hash递增 如果不存在,就会创建一个 并把新增后的值返回 267 * @param key 键 268 * @param item 项 269 * @param by 要增加几(大于0) 270 * @return 271 */ 272 public double hincr(String key, String item,double by){ 273 return redisTemplate.opsForHash().increment(key, item, by); 274 } 275 276 /** 277 * hash递减 278 * @param key 键 279 * @param item 项 280 * @param by 要减少记(小于0) 281 * @return 282 */ 283 public double hdecr(String key, String item,double by){ 284 return redisTemplate.opsForHash().increment(key, item,-by); 285 } 286 287 //============================set============================= 288 /** 289 * 根据key获取Set中的所有值 290 * @param key 键 291 * @return 292 */ 293 public Set<Object> sGet(String key){ 294 try { 295 return redisTemplate.opsForSet().members(key); 296 } catch (Exception e) { 297 e.printStackTrace(); 298 return null; 299 } 300 } 301 302 /** 303 * 根据value从一个set中查询,是否存在 304 * @param key 键 305 * @param value 值 306 * @return true 存在 false不存在 307 */ 308 public boolean sHasKey(String key,Object value){ 309 try { 310 return redisTemplate.opsForSet().isMember(key, value); 311 } catch (Exception e) { 312 e.printStackTrace(); 313 return false; 314 } 315 } 316 317 /** 318 * 将数据放入set缓存 319 * @param key 键 320 * @param values 值 可以是多个 321 * @return 成功个数 322 */ 323 public long sSet(String key, Object...values) { 324 try { 325 return redisTemplate.opsForSet().add(key, values); 326 } catch (Exception e) { 327 e.printStackTrace(); 328 return 0; 329 } 330 } 331 332 /** 333 * 将set数据放入缓存 334 * @param key 键 335 * @param time 时间(秒) 336 * @param values 值 可以是多个 337 * @return 成功个数 338 */ 339 public long sSetAndTime(String key,long time,Object...values) { 340 try { 341 Long count = redisTemplate.opsForSet().add(key, values); 342 if(time>0) { 343 expire(key, time); 344 } 345 return count; 346 } catch (Exception e) { 347 e.printStackTrace(); 348 return 0; 349 } 350 } 351 352 /** 353 * 获取set缓存的长度 354 * @param key 键 355 * @return 356 */ 357 public long sGetSetSize(String key){ 358 try { 359 return redisTemplate.opsForSet().size(key); 360 } catch (Exception e) { 361 e.printStackTrace(); 362 return 0; 363 } 364 } 365 366 /** 367 * 移除值为value的 368 * @param key 键 369 * @param values 值 可以是多个 370 * @return 移除的个数 371 */ 372 public long setRemove(String key, Object ...values) { 373 try { 374 Long count = redisTemplate.opsForSet().remove(key, values); 375 return count; 376 } catch (Exception e) { 377 e.printStackTrace(); 378 return 0; 379 } 380 } 381 //===============================list================================= 382 383 /** 384 * 获取list缓存的内容 385 * @param key 键 386 * @param start 开始 387 * @param end 结束 0 到 -1代表所有值 388 * @return 389 */ 390 public List<Object> lGet(String key, long start, long end){ 391 try { 392 return redisTemplate.opsForList().range(key, start, end); 393 } catch (Exception e) { 394 e.printStackTrace(); 395 return null; 396 } 397 } 398 399 /** 400 * 获取list缓存的长度 401 * @param key 键 402 * @return 403 */ 404 public long lGetListSize(String key){ 405 try { 406 return redisTemplate.opsForList().size(key); 407 } catch (Exception e) { 408 e.printStackTrace(); 409 return 0; 410 } 411 } 412 413 /** 414 * 通过索引 获取list中的值 415 * @param key 键 416 * @param index 索引 index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推 417 * @return 418 */ 419 public Object lGetIndex(String key,long index){ 420 try { 421 return redisTemplate.opsForList().index(key, index); 422 } catch (Exception e) { 423 e.printStackTrace(); 424 return null; 425 } 426 } 427 428 /** 429 * 将list放入缓存 430 * @param key 键 431 * @param value 值 432 * @return 433 */ 434 public boolean lSet(String key, Object value) { 435 try { 436 redisTemplate.opsForList().rightPush(key, value); 437 return true; 438 } catch (Exception e) { 439 e.printStackTrace(); 440 return false; 441 } 442 } 443 444 /** 445 * 将list放入缓存 446 * @param key 键 447 * @param value 值 448 * @param time 时间(秒) 449 * @return 450 */ 451 public boolean lSet(String key, Object value, long time) { 452 try { 453 redisTemplate.opsForList().rightPush(key, value); 454 if (time > 0) { 455 expire(key, time); 456 } 457 return true; 458 } catch (Exception e) { 459 e.printStackTrace(); 460 return false; 461 } 462 } 463 464 /** 465 * 将list放入缓存 466 * @param key 键 467 * @param value 值 468 * @return 469 */ 470 public boolean lSet(String key, List<Object> value) { 471 try { 472 redisTemplate.opsForList().rightPushAll(key, value); 473 return true; 474 } catch (Exception e) { 475 e.printStackTrace(); 476 return false; 477 } 478 } 479 480 /** 481 * 将list放入缓存 482 * @param key 键 483 * @param value 值 484 * @param time 时间(秒) 485 * @return 486 */ 487 public boolean lSet(String key, List<Object> value, long time) { 488 try { 489 redisTemplate.opsForList().rightPushAll(key, value); 490 if (time > 0) { 491 expire(key, time); 492 } 493 return true; 494 } catch (Exception e) { 495 e.printStackTrace(); 496 return false; 497 } 498 } 499 500 /** 501 * 根据索引修改list中的某条数据 502 * @param key 键 503 * @param index 索引 504 * @param value 值 505 * @return 506 */ 507 public boolean lUpdateIndex(String key, long index,Object value) { 508 try { 509 redisTemplate.opsForList().set(key, index, value); 510 return true; 511 } catch (Exception e) { 512 e.printStackTrace(); 513 return false; 514 } 515 } 516 517 /** 518 * 移除N个值为value 519 * @param key 键 520 * @param count 移除多少个 521 * @param value 值 522 * @return 移除的个数 523 */ 524 public long lRemove(String key,long count,Object value) { 525 try { 526 Long remove = redisTemplate.opsForList().remove(key, count, value); 527 return remove; 528 } catch (Exception e) { 529 e.printStackTrace(); 530 return 0; 531 } 532 } 533 534 /** 535 * 模糊查询获取key值 536 * @param pattern 537 * @return 538 */ 539 public Set keys(String pattern){ 540 return redisTemplate.keys(pattern); 541 } 542 543 /** 544 * 使用Redis的消息队列 545 * @param channel 546 * @param message 消息内容 547 */ 548 public void convertAndSend(String channel, Object message){ 549 redisTemplate.convertAndSend(channel,message); 550 } 551 552 /** 553 * 根据起始结束序号遍历Redis中的list 554 * @param listKey 555 * @param start 起始序号 556 * @param end 结束序号 557 */ 558 public List<Object> rangeList(String listKey, long start, long end) { 559 //绑定操作 560 BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey); 561 //查询数据 562 return boundValueOperations.range(start, end); 563 } 564 /** 565 * 弹出右边的值 --- 并且移除这个值 566 * @param listKey 567 */ 568 public Object rifhtPop(String listKey){ 569 //绑定操作 570 BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey); 571 return boundValueOperations.rightPop(); 572 } 573 }
2.RedisConf.java
1 import com.fasterxml.jackson.annotation.JsonAutoDetect; 2 import com.fasterxml.jackson.annotation.PropertyAccessor; 3 import com.fasterxml.jackson.databind.ObjectMapper; 4 import org.springframework.cache.annotation.CachingConfigurerSupport; 5 import org.springframework.cache.annotation.EnableCaching; 6 import org.springframework.context.annotation.Bean; 7 import org.springframework.context.annotation.Configuration; 8 import org.springframework.data.redis.connection.RedisConnectionFactory; 9 import org.springframework.data.redis.core.*; 10 import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer; 11 import org.springframework.data.redis.serializer.StringRedisSerializer; 12 13 /** 14 * redis配置类 15 */ 16 @Configuration 17 //开启注解 18 @EnableCaching 19 public class RedisConfig extends CachingConfigurerSupport { 20 21 /** 22 * retemplate相关配置 23 * @param factory 24 * @return 25 */ 26 @Bean 27 public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) { 28 29 RedisTemplate<String, Object> template = new RedisTemplate<>(); 30 // 配置连接工厂 31 template.setConnectionFactory(factory); 32 33 //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值(默认使用JDK的序列化方式) 34 Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class); 35 36 ObjectMapper om = new ObjectMapper(); 37 // 指定要序列化的域,field,get和set,以及修饰符范围,ANY是都有包括private和public 38 om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); 39 // 指定序列化输入的类型,类必须是非final修饰的,final修饰的类,比如String,Integer等会跑出异常 40 om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); 41 jacksonSeial.setObjectMapper(om); 42 43 // 值采用json序列化 44 template.setValueSerializer(jacksonSeial); 45 //使用StringRedisSerializer来序列化和反序列化redis的key值 46 template.setKeySerializer(new StringRedisSerializer()); 47 48 // 设置hash key 和value序列化模式 49 template.setHashKeySerializer(new StringRedisSerializer()); 50 template.setHashValueSerializer(jacksonSeial); 51 template.afterPropertiesSet(); 52 53 return template; 54 } 55 56 /** 57 * 对hash类型的数据操作 58 * 59 * @param redisTemplate 60 * @return 61 */ 62 @Bean 63 public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) { 64 return redisTemplate.opsForHash(); 65 } 66 67 /** 68 * 对redis字符串类型数据操作 69 * 70 * @param redisTemplate 71 * @return 72 */ 73 @Bean 74 public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) { 75 return redisTemplate.opsForValue(); 76 } 77 78 /** 79 * 对链表类型的数据操作 80 * 81 * @param redisTemplate 82 * @return 83 */ 84 @Bean 85 public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) { 86 return redisTemplate.opsForList(); 87 } 88 89 /** 90 * 对无序集合类型的数据操作 91 * 92 * @param redisTemplate 93 * @return 94 */ 95 @Bean 96 public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) { 97 return redisTemplate.opsForSet(); 98 } 99 100 /** 101 * 对有序集合类型的数据操作 102 * 103 * @param redisTemplate 104 * @return 105 */ 106 @Bean 107 public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) { 108 return redisTemplate.opsForZSet(); 109 } 110 }