Spring整合spring-data-redis
1、spring-redis.xml
1<?xml version="1.0" encoding="UTF-8"?> 2<beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" 4 xsi:schemaLocation="http://www.springframework.org/schema/beans 5 http://www.springframework.org/schema/beans/spring-beans-4.3.xsd 6 http://www.springframework.org/schema/context 7 http://www.springframework.org/schema/context/spring-context-4.3.xsd" 8 default-lazy-init="false"> 9 10 <!-- 加载配置文件 --> 11 <context:property-placeholder location="classpath:redis.properties" /> 12 <!-- redis数据源 --> 13 <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig"> 14 <!-- 最大空闲数 --> 15 <property name="maxIdle" value="${redis.maxIdle}" /> 16 <!-- 最大空连接数 --> 17 <property name="maxTotal" value="${redis.maxTotal}" /> 18 <!-- 最大等待时间 --> 19 <property name="maxWaitMillis" value="${redis.maxWaitMillis}" /> 20 <!-- 连接超时时是否阻塞，false时报异常,ture阻塞直到超时, 默认true --> 21 <property name="blockWhenExhausted" value="${redis.blockWhenExhausted}" /> 22 <!-- 返回连接时，检测连接是否成功 --> 23 <property name="testOnBorrow" value="${redis.testOnBorrow}" /> 24 </bean> 25 26 <!-- Spring-redis连接池管理工厂 --> 27 <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"> 28 <!-- IP地址 --> 29 <property name="hostName" value="${redis.host}" /> 30 <!-- 端口号 --> 31 <property name="port" value="${redis.port}" /> 32 <!-- 超时时间 默认2000--> 33 <property name="timeout" value="${redis.timeout}" /> 34 <!-- 连接池配置引用 --> 35 <property name="poolConfig" ref="poolConfig" /> 36 <!-- usePool：是否使用连接池 --> 37 <property name="usePool" value="true"/> 38 </bean> 39 40 <!-- redis template definition --> 41 <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"> 42 <property name="connectionFactory" ref="jedisConnectionFactory" /> 43 <property name="keySerializer"> 44 <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" /> 45 </property> 46 <property name="valueSerializer"> 47 <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" /> 48 </property> 49 <property name="hashKeySerializer"> 50 <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" /> 51 </property> 52 <property name="hashValueSerializer"> 53 <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" /> 54 </property> 55 <!--开启事务 --> 56 <property name="enableTransactionSupport" value="true"></property> 57 </bean> 58 59 <!--自定义redis工具类,在需要缓存的地方注入此类 --> 60 <bean id="redisrCacheManager" class="com.phil.common.redis.RedisCacheManager"> 61 <property name="redisTemplate" ref="redisTemplate" /> 62 </bean> 63</beans>
2、RedisCacheManager.java
1package com.phil.common.redis; 2 3import java.util.List; 4import java.util.Map; 5import java.util.Set; 6import java.util.concurrent.TimeUnit; 7 8import org.springframework.data.redis.core.RedisTemplate; 9import org.springframework.util.CollectionUtils; 10 11/** 12 * Redis Util 13 * @author phil 14 * @date 2017年8月14日 15 * 16 */ 17public class RedisCacheManager { 18 19 private RedisTemplate<String, Object> redisTemplate; 20 21 public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) { 22 this.redisTemplate = redisTemplate; 23 } 24 25 26 /** 27 * 指定缓存失效时间 28 * 29 * @param key 30 * 键 31 * @param time 32 * 时间(秒) 33 * @return 34 */ 35 public boolean expire(String key, long time) { 36 try { 37 if (time > 0) { 38 redisTemplate.expire(key, time, TimeUnit.SECONDS); 39 } 40 return true; 41 } catch (Exception e) { 42 e.printStackTrace(); 43 return false; 44 } 45 } 46 47 /** 48 * 根据key 获取过期时间 49 * 50 * @param key 51 * 键 不能为null 52 * @return 时间(秒) 返回0代表为永久有效 53 */ 54 public long getExpire(String key) { 55 return redisTemplate.getExpire(key, TimeUnit.SECONDS); 56 } 57 58 /** 59 * 判断key是否存在 60 * 61 * @param key 62 * 键 63 * @return true 存在 false不存在 64 */ 65 public boolean hasKey(String key) { 66 try { 67 return redisTemplate.hasKey(key); 68 } catch (Exception e) { 69 e.printStackTrace(); 70 return false; 71 } 72 } 73 74 /** 75 * 删除缓存 76 * 77 * @param key 78 * 可以传一个值 或多个 79 */ 80 @SuppressWarnings("unchecked") 81 public void del(String... key) { 82 if (key != null && key.length > 0) { 83 if (key.length == 1) { 84 redisTemplate.delete(key[0]); 85 } else { 86 redisTemplate.delete(CollectionUtils.arrayToList(key)); 87 } 88 } 89 } 90 91 // ============================String============================= 92 /** 93 * 普通缓存获取 94 * 95 * @param key 96 * 键 97 * @return 值 98 */ 99 public Object get(String key) { 100 return key == null ? null : redisTemplate.opsForValue().get(key); 101 } 102 103 /** 104 * 普通缓存放入 105 * 106 * @param key 107 * 键 108 * @param value 109 * 值 110 * @return true成功 false失败 111 */ 112 public boolean set(String key, Object value) { 113 try { 114 redisTemplate.opsForValue().set(key, value); 115 return true; 116 } catch (Exception e) { 117 e.printStackTrace(); 118 return false; 119 } 120 121 } 122 123 /** 124 * 普通缓存放入并设置时间 125 * 126 * @param key 127 * 键 128 * @param value 129 * 值 130 * @param time 131 * 时间(秒) time要大于0 如果time小于等于0 将设置无限期 132 * @return true成功 false 失败 133 */ 134 public boolean set(String key, Object value, long time) { 135 try { 136 if (time > 0) { 137 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS); 138 } else { 139 set(key, value); 140 } 141 return true; 142 } catch (Exception e) { 143 e.printStackTrace(); 144 return false; 145 } 146 } 147 148 /** 149 * 递增 150 * 151 * @param key 152 * 键 153 * @param by 154 * 要增加几(大于0) 155 * @return 156 */ 157 public long incr(String key, long delta) { 158 if (delta < 0) { 159 throw new RuntimeException("递增因子必须大于0"); 160 } 161 return redisTemplate.opsForValue().increment(key, delta); 162 } 163 164 /** 165 * 递减 166 * 167 * @param key 168 * 键 169 * @param by 170 * 要减少几(小于0) 171 * @return 172 */ 173 public long decr(String key, long delta) { 174 if (delta < 0) { 175 throw new RuntimeException("递减因子必须大于0"); 176 } 177 return redisTemplate.opsForValue().increment(key, -delta); 178 } 179 180 // ================================Map================================= 181 /** 182 * HashGet 183 * 184 * @param key 185 * 键 不能为null 186 * @param item 187 * 项 不能为null 188 * @return 值 189 */ 190 public Object hget(String key, String item) { 191 return redisTemplate.opsForHash().get(key, item); 192 } 193 194 /** 195 * 获取hashKey对应的所有键值 196 * 197 * @param key 198 * 键 199 * @return 对应的多个键值 200 */ 201 public Map<Object, Object> hmget(String key) { 202 return redisTemplate.opsForHash().entries(key); 203 } 204 205 /** 206 * HashSet 207 * 208 * @param key 209 * 键 210 * @param map 211 * 对应多个键值 212 * @return true 成功 false 失败 213 */ 214 public boolean hmset(String key, Map<String, Object> map) { 215 try { 216 redisTemplate.opsForHash().putAll(key, map); 217 return true; 218 } catch (Exception e) { 219 e.printStackTrace(); 220 return false; 221 } 222 } 223 224 /** 225 * HashSet 并设置时间 226 * 227 * @param key 228 * 键 229 * @param map 230 * 对应多个键值 231 * @param time 232 * 时间(秒) 233 * @return true成功 false失败 234 */ 235 public boolean hmset(String key, Map<String, Object> map, long time) { 236 try { 237 redisTemplate.opsForHash().putAll(key, map); 238 if (time > 0) { 239 expire(key, time); 240 } 241 return true; 242 } catch (Exception e) { 243 e.printStackTrace(); 244 return false; 245 } 246 } 247 248 /** 249 * 向一张hash表中放入数据,如果不存在将创建 250 * 251 * @param key 252 * 键 253 * @param item 254 * 项 255 * @param value 256 * 值 257 * @return true 成功 false失败 258 */ 259 public boolean hset(String key, String item, Object value) { 260 try { 261 redisTemplate.opsForHash().put(key, item, value); 262 return true; 263 } catch (Exception e) { 264 e.printStackTrace(); 265 return false; 266 } 267 } 268 269 /** 270 * 向一张hash表中放入数据,如果不存在将创建 271 * 272 * @param key 273 * 键 274 * @param item 275 * 项 276 * @param value 277 * 值 278 * @param time 279 * 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间 280 * @return true 成功 false失败 281 */ 282 public boolean hset(String key, String item, Object value, long time) { 283 try { 284 redisTemplate.opsForHash().put(key, item, value); 285 if (time > 0) { 286 expire(key, time); 287 } 288 return true; 289 } catch (Exception e) { 290 e.printStackTrace(); 291 return false; 292 } 293 } 294 295 /** 296 * 删除hash表中的值 297 * 298 * @param key 299 * 键 不能为null 300 * @param item 301 * 项 可以使多个 不能为null 302 */ 303 public void hdel(String key, Object... item) { 304 redisTemplate.opsForHash().delete(key, item); 305 } 306 307 /** 308 * 判断hash表中是否有该项的值 309 * 310 * @param key 311 * 键 不能为null 312 * @param item 313 * 项 不能为null 314 * @return true 存在 false不存在 315 */ 316 public boolean hHasKey(String key, String item) { 317 return redisTemplate.opsForHash().hasKey(key, item); 318 } 319 320 /** 321 * hash递增 如果不存在,就会创建一个 并把新增后的值返回 322 * 323 * @param key 324 * 键 325 * @param item 326 * 项 327 * @param by 328 * 要增加几(大于0) 329 * @return 330 */ 331 public double hincr(String key, String item, double by) { 332 return redisTemplate.opsForHash().increment(key, item, by); 333 } 334 335 /** 336 * hash递减 337 * 338 * @param key 339 * 键 340 * @param item 341 * 项 342 * @param by 343 * 要减少记(小于0) 344 * @return 345 */ 346 public double hdecr(String key, String item, double by) { 347 return redisTemplate.opsForHash().increment(key, item, -by); 348 } 349 350 // ============================set============================= 351 /** 352 * 根据key获取Set中的所有值 353 * 354 * @param key 355 * 键 356 * @return 357 */ 358 public Set<Object> sGet(String key) { 359 try { 360 return redisTemplate.opsForSet().members(key); 361 } catch (Exception e) { 362 e.printStackTrace(); 363 return null; 364 } 365 } 366 367 /** 368 * 根据value从一个set中查询,是否存在 369 * 370 * @param key 371 * 键 372 * @param value 373 * 值 374 * @return true 存在 false不存在 375 */ 376 public boolean sHasKey(String key, Object value) { 377 try { 378 return redisTemplate.opsForSet().isMember(key, value); 379 } catch (Exception e) { 380 e.printStackTrace(); 381 return false; 382 } 383 } 384 385 /** 386 * 将数据放入set缓存 387 * 388 * @param key 389 * 键 390 * @param values 391 * 值 可以是多个 392 * @return 成功个数 393 */ 394 public long sSet(String key, Object... values) { 395 try { 396 return redisTemplate.opsForSet().add(key, values); 397 } catch (Exception e) { 398 e.printStackTrace(); 399 return 0; 400 } 401 } 402 403 /** 404 * 将set数据放入缓存 405 * 406 * @param key 407 * 键 408 * @param time 409 * 时间(秒) 410 * @param values 411 * 值 可以是多个 412 * @return 成功个数 413 */ 414 public long sSetAndTime(String key, long time, Object... values) { 415 try { 416 Long count = redisTemplate.opsForSet().add(key, values); 417 if (time > 0) 418 expire(key, time); 419 return count; 420 } catch (Exception e) { 421 e.printStackTrace(); 422 return 0; 423 } 424 } 425 426 /** 427 * 获取set缓存的长度 428 * 429 * @param key 430 * 键 431 * @return 432 */ 433 public long sGetSetSize(String key) { 434 try { 435 return redisTemplate.opsForSet().size(key); 436 } catch (Exception e) { 437 e.printStackTrace(); 438 return 0; 439 } 440 } 441 442 /** 443 * 移除值为value的 444 * 445 * @param key 446 * 键 447 * @param values 448 * 值 可以是多个 449 * @return 移除的个数 450 */ 451 public long setRemove(String key, Object... values) { 452 try { 453 Long count = redisTemplate.opsForSet().remove(key, values); 454 return count; 455 } catch (Exception e) { 456 e.printStackTrace(); 457 return 0; 458 } 459 } 460 // ===============================list================================= 461 462 /** 463 * 获取list缓存的内容 464 * 465 * @param key 466 * 键 467 * @param start 468 * 开始 469 * @param end 470 * 结束 0 到 -1代表所有值 471 * @return 472 */ 473 public List<Object> lGet(String key, long start, long end) { 474 try { 475 return redisTemplate.opsForList().range(key, start, end); 476 } catch (Exception e) { 477 e.printStackTrace(); 478 return null; 479 } 480 } 481 482 /** 483 * 获取list缓存的长度 484 * 485 * @param key 486 * 键 487 * @return 488 */ 489 public long lGetListSize(String key) { 490 try { 491 return redisTemplate.opsForList().size(key); 492 } catch (Exception e) { 493 e.printStackTrace(); 494 return 0; 495 } 496 } 497 498 /** 499 * 通过索引 获取list中的值 500 * 501 * @param key 502 * 键 503 * @param index 504 * 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推 505 * @return 506 */ 507 public Object lGetIndex(String key, long index) { 508 try { 509 return redisTemplate.opsForList().index(key, index); 510 } catch (Exception e) { 511 e.printStackTrace(); 512 return null; 513 } 514 } 515 516 /** 517 * 将list放入缓存 518 * 519 * @param key 520 * 键 521 * @param value 522 * 值 523 * @param time 524 * 时间(秒) 525 * @return 526 */ 527 public boolean lSet(String key, Object value) { 528 try { 529 redisTemplate.opsForList().rightPush(key, value); 530 return true; 531 } catch (Exception e) { 532 e.printStackTrace(); 533 return false; 534 } 535 } 536 537 /** 538 * 将list放入缓存 539 * 540 * @param key 541 * 键 542 * @param value 543 * 值 544 * @param time 545 * 时间(秒) 546 * @return 547 */ 548 public boolean lSet(String key, Object value, long time) { 549 try { 550 redisTemplate.opsForList().rightPush(key, value); 551 if (time > 0) 552 expire(key, time); 553 return true; 554 } catch (Exception e) { 555 e.printStackTrace(); 556 return false; 557 } 558 } 559 560 /** 561 * 将list放入缓存 562 * 563 * @param key 564 * 键 565 * @param value 566 * 值 567 * @param time 568 * 时间(秒) 569 * @return 570 */ 571 public boolean lSet(String key, List<Object> value) { 572 try { 573 redisTemplate.opsForList().rightPushAll(key, value); 574 return true; 575 } catch (Exception e) { 576 e.printStackTrace(); 577 return false; 578 } 579 } 580 581 /** 582 * 将list放入缓存 583 * 584 * @param key 585 * 键 586 * @param value 587 * 值 588 * @param time 589 * 时间(秒) 590 * @return 591 */ 592 public boolean lSet(String key, List<Object> value, long time) { 593 try { 594 redisTemplate.opsForList().rightPushAll(key, value); 595 if (time > 0) 596 expire(key, time); 597 return true; 598 } catch (Exception e) { 599 e.printStackTrace(); 600 return false; 601 } 602 } 603 604 /** 605 * 根据索引修改list中的某条数据 606 * 607 * @param key 608 * 键 609 * @param index 610 * 索引 611 * @param value 612 * 值 613 * @return 614 */ 615 public boolean lUpdateIndex(String key, long index, Object value) { 616 try { 617 redisTemplate.opsForList().set(key, index, value); 618 return true; 619 } catch (Exception e) { 620 e.printStackTrace(); 621 return false; 622 } 623 } 624 625 /** 626 * 移除N个值为value 627 * 628 * @param key 629 * 键 630 * @param count 631 * 移除多少个 632 * @param value 633 * 值 634 * @return 移除的个数 635 */ 636 public long lRemove(String key, long count, Object value) { 637 try { 638 Long remove = redisTemplate.opsForList().remove(key, count, value); 639 return remove; 640 } catch (Exception e) { 641 e.printStackTrace(); 642 return 0; 643 } 644 } 645}