1、配置文件pom里面添加redis依赖
<!-- redis客户端:Jedis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
2、配置文件
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.xsd 6 http://www.springframework.org/schema/context 7 http://www.springframework.org/schema/context/spring-context.xsd"> 8 <!-- Redis连接池的设置 --> 9 <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig"> 10 <!-- 控制一个pool可分配多少个jedis实例 --> 11 <property name="maxTotal" value="${redis.pool.maxActive}" /> 12 <!-- 连接池中最多可空闲maxIdle个连接 ，这里取值为20，表示即使没有数据库连接时依然可以保持20空闲的连接，而不被清除，随时处于待命状态。 --> 13 <property name="maxIdle" value="${redis.pool.maxIdle}" /> 14 <!-- 最大等待时间:当没有可用连接时,连接池等待连接被归还的最大时间(以毫秒计数),超过时间则抛出异常 --> 15 <property name="maxWaitMillis" value="${redis.pool.maxWait}" /> 16 <!-- 在获取连接的时候检查有效性 --> 17 <property name="testOnBorrow" value="${redis.pool.testOnBorrow}" /> 18 </bean> 19 20 <!-- 创建Redis连接池，并做相关配置 --> 21 <bean id="jedisWritePool" class="com.imooc.o2o.cache.JedisPoolWriper" 22 depends-on="jedisPoolConfig"> 23 <constructor-arg index="0" ref="jedisPoolConfig" /> 24 <constructor-arg index="1" value="${redis.hostname}" /> 25 <constructor-arg index="2" value="${redis.port}" type="int" /> 26 27 </bean> 28 29 <!-- 创建Redis工具类，封装好Redis的连接以进行相关的操作 --> 30 <bean id="jedisUtil" class="com.imooc.o2o.cache.JedisUtil" scope="singleton"> 31 <property name="jedisPool"> 32 <ref bean="jedisWritePool" /> 33 </property> 34 </bean> 35 <!-- Redis的key操作 --> 36 <bean id="jedisKeys" class="com.imooc.o2o.cache.JedisUtil$Keys" 37 scope="singleton"> 38 <constructor-arg ref="jedisUtil"></constructor-arg> 39 </bean> 40 <!-- Redis的Strings操作 --> 41 <bean id="jedisStrings" class="com.imooc.o2o.cache.JedisUtil$Strings" 42 scope="singleton"> 43 <constructor-arg ref="jedisUtil"></constructor-arg> 44 </bean> 45 <!-- Redis的Lists操作 --> 46 <bean id="jedisLists" class="com.imooc.o2o.cache.JedisUtil$Lists" 47 scope="singleton"> 48 <constructor-arg ref="jedisUtil"></constructor-arg> 49 </bean> 50 <!-- Redis的Sets操作 --> 51 <bean id="jedisSets" class="com.imooc.o2o.cache.JedisUtil$Sets" 52 scope="singleton"> 53 <constructor-arg ref="jedisUtil"></constructor-arg> 54 </bean> 55 <!-- Redis的HashMap操作 --> 56 <bean id="jedisHash" class="com.imooc.o2o.cache.JedisUtil$Hash" 57 scope="singleton"> 58 <constructor-arg ref="jedisUtil"></constructor-arg> 59 </bean> 60 </beans>
1 redis.hostname=127.0.0.1 2 redis.port=6379 3 redis.database=0 4 redis.pool.maxActive=100 5 redis.pool.maxIdle=20 6 redis.pool.maxWait=3000 7 redis.pool.testOnBorrow=true 8 redis.password=sxmsapp
3、修改配置文件spring-dao.xml
4、配置redis连接池
1 import redis.clients.jedis.JedisPool; 2 import redis.clients.jedis.JedisPoolConfig; 3 4 /** 5 * 强指定redis的JedisPool接口构造函数，这样才能在centos成功创建jedispool 6 * 7 */ 8 public class JedisPoolWriper { 9 /** Redis连接池对象 */ 10 private JedisPool jedisPool; 11 12 public JedisPoolWriper(final JedisPoolConfig poolConfig, final String host, 13 final int port) { 14 try { 15 jedisPool = new JedisPool(poolConfig, host, port); 16 } catch (Exception e) { 17 e.printStackTrace(); 18 } 19 } 20 21 /** 22 * 获取Redis连接池对象 23 * @return 24 */ 25 public JedisPool getJedisPool() { 26 return jedisPool; 27 } 28 29 /** 30 * 注入Redis连接池对象 31 * @param jedisPool 32 */ 33 public void setJedisPool(JedisPool jedisPool) { 34 this.jedisPool = jedisPool; 35 } 36 37 }
5、操作redis
1 package com.imooc.o2o.cache; 2 3 import java.util.List; 4 import java.util.Map; 5 import java.util.Set; 6 7 import redis.clients.jedis.BinaryClient.LIST_POSITION; 8 import redis.clients.jedis.Jedis; 9 import redis.clients.jedis.JedisPool; 10 import redis.clients.jedis.SortingParams; 11 import redis.clients.util.SafeEncoder; 12 13 public class JedisUtil { 14 /** 15 * 缓存生存时间 16 */ 17 private final int expire = 60000; 18 /** 操作Key的方法 */ 19 public Keys KEYS; 20 /** 对存储结构为String类型的操作 */ 21 public Strings STRINGS; 22 /** 对存储结构为List类型的操作 */ 23 public Lists LISTS; 24 /** 对存储结构为Set类型的操作 */ 25 public Sets SETS; 26 /** 对存储结构为HashMap类型的操作 */ 27 public Hash HASH; 28 29 /** Redis连接池对象 */ 30 private JedisPool jedisPool; 31 32 /** 33 * 获取redis连接池 34 * 35 * @return 36 */ 37 public JedisPool getJedisPool() { 38 return jedisPool; 39 } 40 41 /** 42 * 设置redis连接池 43 * 44 * @return 45 */ 46 public void setJedisPool(JedisPoolWriper jedisPoolWriper) { 47 this.jedisPool = jedisPoolWriper.getJedisPool(); 48 } 49 50 /** 51 * 从jedis连接池中获取获取jedis对象 52 * 53 * @return 54 */ 55 public Jedis getJedis() { 56 return jedisPool.getResource(); 57 } 58 59 /** 60 * 设置过期时间 61 * 62 * @author xiangze 63 * @param key 64 * @param seconds 65 */ 66 public void expire(String key, int seconds) { 67 if (seconds <= 0) { 68 return; 69 } 70 Jedis jedis = getJedis(); 71 jedis.expire(key, seconds); 72 jedis.close(); 73 } 74 75 /** 76 * 设置默认过期时间 77 * 78 * @author xiangze 79 * @param key 80 */ 81 public void expire(String key) { 82 expire(key, expire); 83 } 84 85 // *******************************************Keys*******************************************// 86 public class Keys { 87 88 /** 89 * 清空所有key 90 */ 91 public String flushAll() { 92 Jedis jedis = getJedis(); 93 String stata = jedis.flushAll(); 94 jedis.close(); 95 return stata; 96 } 97 98 /** 99 * 更改key 100 * 101 * @param String 102 * oldkey 103 * @param String 104 * newkey 105 * @return 状态码 106 */ 107 public String rename(String oldkey, String newkey) { 108 return rename(SafeEncoder.encode(oldkey), SafeEncoder.encode(newkey)); 109 } 110 111 /** 112 * 更改key,仅当新key不存在时才执行 113 * 114 * @param String 115 * oldkey 116 * @param String 117 * newkey 118 * @return 状态码 119 */ 120 public long renamenx(String oldkey, String newkey) { 121 Jedis jedis = getJedis(); 122 long status = jedis.renamenx(oldkey, newkey); 123 jedis.close(); 124 return status; 125 } 126 127 /** 128 * 更改key 129 * 130 * @param String 131 * oldkey 132 * @param String 133 * newkey 134 * @return 状态码 135 */ 136 public String rename(byte[] oldkey, byte[] newkey) { 137 Jedis jedis = getJedis(); 138 String status = jedis.rename(oldkey, newkey); 139 jedis.close(); 140 return status; 141 } 142 143 /** 144 * 设置key的过期时间，以秒为单位 145 * 146 * @param String 147 * key 148 * @param 时间 149 * ,已秒为单位 150 * @return 影响的记录数 151 */ 152 public long expired(String key, int seconds) { 153 Jedis jedis = getJedis(); 154 long count = jedis.expire(key, seconds); 155 jedis.close(); 156 return count; 157 } 158 159 /** 160 * 设置key的过期时间,它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00，格里高利历）的偏移量。 161 * 162 * @param String 163 * key 164 * @param 时间 165 * ,已秒为单位 166 * @return 影响的记录数 167 */ 168 public long expireAt(String key, long timestamp) { 169 Jedis jedis = getJedis(); 170 long count = jedis.expireAt(key, timestamp); 171 jedis.close(); 172 return count; 173 } 174 175 /** 176 * 查询key的过期时间 177 * 178 * @param String 179 * key 180 * @return 以秒为单位的时间表示 181 */ 182 public long ttl(String key) { 183 // ShardedJedis sjedis = getShardedJedis(); 184 Jedis sjedis = getJedis(); 185 long len = sjedis.ttl(key); 186 sjedis.close(); 187 return len; 188 } 189 190 /** 191 * 取消对key过期时间的设置 192 * 193 * @param key 194 * @return 影响的记录数 195 */ 196 public long persist(String key) { 197 Jedis jedis = getJedis(); 198 long count = jedis.persist(key); 199 jedis.close(); 200 return count; 201 } 202 203 /** 204 * 删除keys对应的记录,可以是多个key 205 * 206 * @param String 207 * ... keys 208 * @return 删除的记录数 209 */ 210 public long del(String... keys) { 211 Jedis jedis = getJedis(); 212 long count = jedis.del(keys); 213 jedis.close(); 214 return count; 215 } 216 217 /** 218 * 删除keys对应的记录,可以是多个key 219 * 220 * @param String 221 * ... keys 222 * @return 删除的记录数 223 */ 224 public long del(byte[]... keys) { 225 Jedis jedis = getJedis(); 226 long count = jedis.del(keys); 227 jedis.close(); 228 return count; 229 } 230 231 /** 232 * 判断key是否存在 233 * 234 * @param String 235 * key 236 * @return boolean 237 */ 238 public boolean exists(String key) { 239 // ShardedJedis sjedis = getShardedJedis(); 240 Jedis sjedis = getJedis(); 241 boolean exis = sjedis.exists(key); 242 sjedis.close(); 243 return exis; 244 } 245 246 /** 247 * 对List,Set,SortSet进行排序,如果集合数据较大应避免使用这个方法 248 * 249 * @param String 250 * key 251 * @return List<String> 集合的全部记录 252 **/ 253 public List<String> sort(String key) { 254 // ShardedJedis sjedis = getShardedJedis(); 255 Jedis sjedis = getJedis(); 256 List<String> list = sjedis.sort(key); 257 sjedis.close(); 258 return list; 259 } 260 261 /** 262 * 对List,Set,SortSet进行排序或limit 263 * 264 * @param String 265 * key 266 * @param SortingParams 267 * parame 定义排序类型或limit的起止位置. 268 * @return List<String> 全部或部分记录 269 **/ 270 public List<String> sort(String key, SortingParams parame) { 271 // ShardedJedis sjedis = getShardedJedis(); 272 Jedis sjedis = getJedis(); 273 List<String> list = sjedis.sort(key, parame); 274 sjedis.close(); 275 return list; 276 } 277 278 /** 279 * 返回指定key存储的类型 280 * 281 * @param String 282 * key 283 * @return String string|list|set|zset|hash 284 **/ 285 public String type(String key) { 286 // ShardedJedis sjedis = getShardedJedis(); 287 Jedis sjedis = getJedis(); 288 String type = sjedis.type(key); 289 sjedis.close(); 290 return type; 291 } 292 293 /** 294 * 查找所有匹配给定的模式的键 295 * 296 * @param String 297 * key的表达式,*表示多个，？表示一个 298 */ 299 public Set<String> keys(String pattern) { 300 Jedis jedis = getJedis(); 301 Set<String> set = jedis.keys(pattern); 302 jedis.close(); 303 return set; 304 } 305 } 306 307 // *******************************************Strings*******************************************// 308 public class Strings { 309 /** 310 * 根据key获取记录 311 * 312 * @param String 313 * key 314 * @return 值 315 */ 316 public String get(String key) { 317 // ShardedJedis sjedis = getShardedJedis(); 318 Jedis sjedis = getJedis(); 319 String value = sjedis.get(key); 320 sjedis.close(); 321 return value; 322 } 323 324 /** 325 * 根据key获取记录 326 * 327 * @param byte[] 328 * key 329 * @return 值 330 */ 331 public byte[] get(byte[] key) { 332 // ShardedJedis sjedis = getShardedJedis(); 333 Jedis sjedis = getJedis(); 334 byte[] value = sjedis.get(key); 335 sjedis.close(); 336 return value; 337 } 338 339 /** 340 * 添加记录,如果记录已存在将覆盖原有的value 341 * 342 * @param String 343 * key 344 * @param String 345 * value 346 * @return 状态码 347 */ 348 public String set(String key, String value) { 349 return set(SafeEncoder.encode(key), SafeEncoder.encode(value)); 350 } 351 352 /** 353 * 添加记录,如果记录已存在将覆盖原有的value 354 * 355 * @param String 356 * key 357 * @param String 358 * value 359 * @return 状态码 360 */ 361 public String set(String key, byte[] value) { 362 return set(SafeEncoder.encode(key), value); 363 } 364 365 /** 366 * 添加记录,如果记录已存在将覆盖原有的value 367 * 368 * @param byte[] 369 * key 370 * @param byte[] 371 * value 372 * @return 状态码 373 */ 374 public String set(byte[] key, byte[] value) { 375 Jedis jedis = getJedis(); 376 String status = jedis.set(key, value); 377 jedis.close(); 378 return status; 379 } 380 381 /** 382 * 添加有过期时间的记录 383 * 384 * @param String 385 * key 386 * @param int 387 * seconds 过期时间，以秒为单位 388 * @param String 389 * value 390 * @return String 操作状态 391 */ 392 public String setEx(String key, int seconds, String value) { 393 Jedis jedis = getJedis(); 394 String str = jedis.setex(key, seconds, value); 395 jedis.close(); 396 return str; 397 } 398 399 /** 400 * 添加有过期时间的记录 401 * 402 * @param String 403 * key 404 * @param int 405 * seconds 过期时间，以秒为单位 406 * @param String 407 * value 408 * @return String 操作状态 409 */ 410 public String setEx(byte[] key, int seconds, byte[] value) { 411 Jedis jedis = getJedis(); 412 String str = jedis.setex(key, seconds, value); 413 jedis.close(); 414 return str; 415 } 416 417 /** 418 * 添加一条记录，仅当给定的key不存在时才插入 419 * 420 * @param String 421 * key 422 * @param String 423 * value 424 * @return long 状态码，1插入成功且key不存在，0未插入，key存在 425 */ 426 public long setnx(String key, String value) { 427 Jedis jedis = getJedis(); 428 long str = jedis.setnx(key, value); 429 jedis.close(); 430 return str; 431 } 432 433 /** 434 * 从指定位置开始插入数据，插入的数据会覆盖指定位置以后的数据<br/> 435 * 例:String str1="123456789";<br/> 436 * 对str1操作后setRange(key,4,0000)，str1="123400009"; 437 * 438 * @param String 439 * key 440 * @param long 441 * offset 442 * @param String 443 * value 444 * @return long value的长度 445 */ 446 public long setRange(String key, long offset, String value) { 447 Jedis jedis = getJedis(); 448 long len = jedis.setrange(key, offset, value); 449 jedis.close(); 450 return len; 451 } 452 453 /** 454 * 在指定的key中追加value 455 * 456 * @param String 457 * key 458 * @param String 459 * value 460 * @return long 追加后value的长度 461 **/ 462 public long append(String key, String value) { 463 Jedis jedis = getJedis(); 464 long len = jedis.append(key, value); 465 jedis.close(); 466 return len; 467 } 468 469 /** 470 * 将key对应的value减去指定的值，只有value可以转为数字时该方法才可用 471 * 472 * @param String 473 * key 474 * @param long 475 * number 要减去的值 476 * @return long 减指定值后的值 477 */ 478 public long decrBy(String key, long number) { 479 Jedis jedis = getJedis(); 480 long len = jedis.decrBy(key, number); 481 jedis.close(); 482 return len; 483 } 484 485 /** 486 * <b>可以作为获取唯一id的方法</b><br/> 487 * 将key对应的value加上指定的值，只有value可以转为数字时该方法才可用 488 * 489 * @param String 490 * key 491 * @param long 492 * number 要减去的值 493 * @return long 相加后的值 494 */ 495 public long incrBy(String key, long number) { 496 Jedis jedis = getJedis(); 497 long len = jedis.incrBy(key, number); 498 jedis.close(); 499 return len; 500 } 501 502 /** 503 * 对指定key对应的value进行截取 504 * 505 * @param String 506 * key 507 * @param long 508 * startOffset 开始位置(包含) 509 * @param long 510 * endOffset 结束位置(包含) 511 * @return String 截取的值 512 */ 513 public String getrange(String key, long startOffset, long endOffset) { 514 // ShardedJedis sjedis = getShardedJedis(); 515 Jedis sjedis = getJedis(); 516 String value = sjedis.getrange(key, startOffset, endOffset); 517 sjedis.close(); 518 return value; 519 } 520 521 /** 522 * 获取并设置指定key对应的value<br/> 523 * 如果key存在返回之前的value,否则返回null 524 * 525 * @param String 526 * key 527 * @param String 528 * value 529 * @return String 原始value或null 530 */ 531 public String getSet(String key, String value) { 532 Jedis jedis = getJedis(); 533 String str = jedis.getSet(key, value); 534 jedis.close(); 535 return str; 536 } 537 538 /** 539 * 批量获取记录,如果指定的key不存在返回List的对应位置将是null 540 * 541 * @param String 542 * keys 543 * @return List<String> 值得集合 544 */ 545 public List<String> mget(String... keys) { 546 Jedis jedis = getJedis(); 547 List<String> str = jedis.mget(keys); 548 jedis.close(); 549 return str; 550 } 551 552 /** 553 * 批量存储记录 554 * 555 * @param String 556 * keysvalues 例:keysvalues="key1","value1","key2","value2"; 557 * @return String 状态码 558 */ 559 public String mset(String... keysvalues) { 560 Jedis jedis = getJedis(); 561 String str = jedis.mset(keysvalues); 562 jedis.close(); 563 return str; 564 } 565 566 /** 567 * 获取key对应的值的长度 568 * 569 * @param String 570 * key 571 * @return value值得长度 572 */ 573 public long strlen(String key) { 574 Jedis jedis = getJedis(); 575 long len = jedis.strlen(key); 576 jedis.close(); 577 return len; 578 } 579 } 580 581 // *******************************************Sets*******************************************// 582 public class Sets { 583 584 /** 585 * 向Set添加一条记录，如果member已存在返回0,否则返回1 586 * 587 * @param String 588 * key 589 * @param String 590 * member 591 * @return 操作码,0或1 592 */ 593 public long sadd(String key, String member) { 594 Jedis jedis = getJedis(); 595 long s = jedis.sadd(key, member); 596 jedis.close(); 597 return s; 598 } 599 600 public long sadd(byte[] key, byte[] member) { 601 Jedis jedis = getJedis(); 602 long s = jedis.sadd(key, member); 603 jedis.close(); 604 return s; 605 } 606 607 /** 608 * 获取给定key中元素个数 609 * 610 * @param String 611 * key 612 * @return 元素个数 613 */ 614 public long scard(String key) { 615 // ShardedJedis sjedis = getShardedJedis(); 616 Jedis sjedis = getJedis(); 617 long len = sjedis.scard(key); 618 sjedis.close(); 619 return len; 620 } 621 622 /** 623 * 返回从第一组和所有的给定集合之间的差异的成员 624 * 625 * @param String 626 * ... keys 627 * @return 差异的成员集合 628 */ 629 public Set<String> sdiff(String... keys) { 630 Jedis jedis = getJedis(); 631 Set<String> set = jedis.sdiff(keys); 632 jedis.close(); 633 return set; 634 } 635 636 /** 637 * 这个命令等于sdiff,但返回的不是结果集,而是将结果集存储在新的集合中，如果目标已存在，则覆盖。 638 * 639 * @param String 640 * newkey 新结果集的key 641 * @param String 642 * ... keys 比较的集合 643 * @return 新集合中的记录数 644 **/ 645 public long sdiffstore(String newkey, String... keys) { 646 Jedis jedis = getJedis(); 647 long s = jedis.sdiffstore(newkey, keys); 648 jedis.close(); 649 return s; 650 } 651 652 /** 653 * 返回给定集合交集的成员,如果其中一个集合为不存在或为空，则返回空Set 654 * 655 * @param String 656 * ... keys 657 * @return 交集成员的集合 658 **/ 659 public Set<String> sinter(String... keys) { 660 Jedis jedis = getJedis(); 661 Set<String> set = jedis.sinter(keys); 662 jedis.close(); 663 return set; 664 } 665 666 /** 667 * 这个命令等于sinter,但返回的不是结果集,而是将结果集存储在新的集合中，如果目标已存在，则覆盖。 668 * 669 * @param String 670 * newkey 新结果集的key 671 * @param String 672 * ... keys 比较的集合 673 * @return 新集合中的记录数 674 **/ 675 public long sinterstore(String newkey, String... keys) { 676 Jedis jedis = getJedis(); 677 long s = jedis.sinterstore(newkey, keys); 678 jedis.close(); 679 return s; 680 } 681 682 /** 683 * 确定一个给定的值是否存在 684 * 685 * @param String 686 * key 687 * @param String 688 * member 要判断的值 689 * @return 存在返回1，不存在返回0 690 **/ 691 public boolean sismember(String key, String member) { 692 // ShardedJedis sjedis = getShardedJedis(); 693 Jedis sjedis = getJedis(); 694 boolean s = sjedis.sismember(key, member); 695 sjedis.close(); 696 return s; 697 } 698 699 /** 700 * 返回集合中的所有成员 701 * 702 * @param String 703 * key 704 * @return 成员集合 705 */ 706 public Set<String> smembers(String key) { 707 // ShardedJedis sjedis = getShardedJedis(); 708 Jedis sjedis = getJedis(); 709 Set<String> set = sjedis.smembers(key); 710 sjedis.close(); 711 return set; 712 } 713 714 public Set<byte[]> smembers(byte[] key) { 715 // ShardedJedis sjedis = getShardedJedis(); 716 Jedis sjedis = getJedis(); 717 Set<byte[]> set = sjedis.smembers(key); 718 sjedis.close(); 719 return set; 720 } 721 722 /** 723 * 将成员从源集合移出放入目标集合 <br/> 724 * 如果源集合不存在或不包哈指定成员，不进行任何操作，返回0<br/> 725 * 否则该成员从源集合上删除，并添加到目标集合，如果目标集合中成员已存在，则只在源集合进行删除 726 * 727 * @param String 728 * srckey 源集合 729 * @param String 730 * dstkey 目标集合 731 * @param String 732 * member 源集合中的成员 733 * @return 状态码，1成功，0失败 734 */ 735 public long smove(String srckey, String dstkey, String member) { 736 Jedis jedis = getJedis(); 737 long s = jedis.smove(srckey, dstkey, member); 738 jedis.close(); 739 return s; 740 } 741 742 /** 743 * 从集合中删除成员 744 * 745 * @param String 746 * key 747 * @return 被删除的成员 748 */ 749 public String spop(String key) { 750 Jedis jedis = getJedis(); 751 String s = jedis.spop(key); 752 jedis.close(); 753 return s; 754 } 755 756 /** 757 * 从集合中删除指定成员 758 * 759 * @param String 760 * key 761 * @param String 762 * member 要删除的成员 763 * @return 状态码，成功返回1，成员不存在返回0 764 */ 765 public long srem(String key, String member) { 766 Jedis jedis = getJedis(); 767 long s = jedis.srem(key, member); 768 jedis.close(); 769 return s; 770 } 771 772 /** 773 * 合并多个集合并返回合并后的结果，合并后的结果集合并不保存<br/> 774 * 775 * @param String 776 * ... keys 777 * @return 合并后的结果集合 778 * @see sunionstore 779 */ 780 public Set<String> sunion(String... keys) { 781 Jedis jedis = getJedis(); 782 Set<String> set = jedis.sunion(keys); 783 jedis.close(); 784 return set; 785 } 786 787 /** 788 * 合并多个集合并将合并后的结果集保存在指定的新集合中，如果新集合已经存在则覆盖 789 * 790 * @param String 791 * newkey 新集合的key 792 * @param String 793 * ... keys 要合并的集合 794 **/ 795 public long sunionstore(String newkey, String... keys) { 796 Jedis jedis = getJedis(); 797 long s = jedis.sunionstore(newkey, keys); 798 jedis.close(); 799 return s; 800 } 801 } 802 803 // *******************************************Hash*******************************************// 804 public class Hash { 805 806 /** 807 * 从hash中删除指定的存储 808 * 809 * @param String 810 * key 811 * @param String 812 * fieid 存储的名字 813 * @return 状态码，1成功，0失败 814 */ 815 public long hdel(String key, String fieid) { 816 Jedis jedis = getJedis(); 817 long s = jedis.hdel(key, fieid); 818 jedis.close(); 819 return s; 820 } 821 822 public long hdel(String key) { 823 Jedis jedis = getJedis(); 824 long s = jedis.del(key); 825 jedis.close(); 826 return s; 827 } 828 829 /** 830 * 测试hash中指定的存储是否存在 831 * 832 * @param String 833 * key 834 * @param String 835 * fieid 存储的名字 836 * @return 1存在，0不存在 837 */ 838 public boolean hexists(String key, String fieid) { 839 // ShardedJedis sjedis = getShardedJedis(); 840 Jedis sjedis = getJedis(); 841 boolean s = sjedis.hexists(key, fieid); 842 sjedis.close(); 843 return s; 844 } 845 846 /** 847 * 返回hash中指定存储位置的值 848 * 849 * @param String 850 * key 851 * @param String 852 * fieid 存储的名字 853 * @return 存储对应的值 854 */ 855 public String hget(String key, String fieid) { 856 // ShardedJedis sjedis = getShardedJedis(); 857 Jedis sjedis = getJedis(); 858 String s = sjedis.hget(key, fieid); 859 sjedis.close(); 860 return s; 861 } 862 863 public byte[] hget(byte[] key, byte[] fieid) { 864 // ShardedJedis sjedis = getShardedJedis(); 865 Jedis sjedis = getJedis(); 866 byte[] s = sjedis.hget(key, fieid); 867 sjedis.close(); 868 return s; 869 } 870 871 /** 872 * 以Map的形式返回hash中的存储和值 873 * 874 * @param String 875 * key 876 * @return Map<Strinig,String> 877 */ 878 public Map<String, String> hgetAll(String key) { 879 // ShardedJedis sjedis = getShardedJedis(); 880 Jedis sjedis = getJedis(); 881 Map<String, String> map = sjedis.hgetAll(key); 882 sjedis.close(); 883 return map; 884 } 885 886 /** 887 * 添加一个对应关系 888 * 889 * @param String 890 * key 891 * @param String 892 * fieid 893 * @param String 894 * value 895 * @return 状态码 1成功，0失败，fieid已存在将更新，也返回0 896 **/ 897 public long hset(String key, String fieid, String value) { 898 Jedis jedis = getJedis(); 899 long s = jedis.hset(key, fieid, value); 900 jedis.close(); 901 return s; 902 } 903 904 public long hset(String key, String fieid, byte[] value) { 905 Jedis jedis = getJedis(); 906 long s = jedis.hset(key.getBytes(), fieid.getBytes(), value); 907 jedis.close(); 908 return s; 909 } 910 911 /** 912 * 添加对应关系，只有在fieid不存在时才执行 913 * 914 * @param String 915 * key 916 * @param String 917 * fieid 918 * @param String 919 * value 920 * @return 状态码 1成功，0失败fieid已存 921 **/ 922 public long hsetnx(String key, String fieid, String value) { 923 Jedis jedis = getJedis(); 924 long s = jedis.hsetnx(key, fieid, value); 925 jedis.close(); 926 return s; 927 } 928 929 /** 930 * 获取hash中value的集合 931 * 932 * @param String 933 * key 934 * @return List<String> 935 */ 936 public List<String> hvals(String key) { 937 // ShardedJedis sjedis = getShardedJedis(); 938 Jedis sjedis = getJedis(); 939 List<String> list = sjedis.hvals(key); 940 sjedis.close(); 941 return list; 942 } 943 944 /** 945 * 在指定的存储位置加上指定的数字，存储位置的值必须可转为数字类型 946 * 947 * @param String 948 * key 949 * @param String 950 * fieid 存储位置 951 * @param String 952 * long value 要增加的值,可以是负数 953 * @return 增加指定数字后，存储位置的值 954 */ 955 public long hincrby(String key, String fieid, long value) { 956 Jedis jedis = getJedis(); 957 long s = jedis.hincrBy(key, fieid, value); 958 jedis.close(); 959 return s; 960 } 961 962 /** 963 * 返回指定hash中的所有存储名字,类似Map中的keySet方法 964 * 965 * @param String 966 * key 967 * @return Set<String> 存储名称的集合 968 */ 969 public Set<String> hkeys(String key) { 970 // ShardedJedis sjedis = getShardedJedis(); 971 Jedis sjedis = getJedis(); 972 Set<String> set = sjedis.hkeys(key); 973 sjedis.close(); 974 return set; 975 } 976 977 /** 978 * 获取hash中存储的个数，类似Map中size方法 979 * 980 * @param String 981 * key 982 * @return long 存储的个数 983 */ 984 public long hlen(String key) { 985 // ShardedJedis sjedis = getShardedJedis(); 986 Jedis sjedis = getJedis(); 987 long len = sjedis.hlen(key); 988 sjedis.close(); 989 return len; 990 } 991 992 /** 993 * 根据多个key，获取对应的value，返回List,如果指定的key不存在,List对应位置为null 994 * 995 * @param String 996 * key 997 * @param String 998 * ... fieids 存储位置 999 * @return List<String> 1000 */ 1001 public List<String> hmget(String key, String... fieids) { 1002 // ShardedJedis sjedis = getShardedJedis(); 1003 Jedis sjedis = getJedis(); 1004 List<String> list = sjedis.hmget(key, fieids); 1005 sjedis.close(); 1006 return list; 1007 } 1008 1009 public List<byte[]> hmget(byte[] key, byte[]... fieids) { 1010 // ShardedJedis sjedis = getShardedJedis(); 1011 Jedis sjedis = getJedis(); 1012 List<byte[]> list = sjedis.hmget(key, fieids); 1013 sjedis.close(); 1014 return list; 1015 } 1016 1017 /** 1018 * 添加对应关系，如果对应关系已存在，则覆盖 1019 * 1020 * @param Strin 1021 * key 1022 * @param Map 1023 * <String,String> 对应关系 1024 * @return 状态，成功返回OK 1025 */ 1026 public String hmset(String key, Map<String, String> map) { 1027 Jedis jedis = getJedis(); 1028 String s = jedis.hmset(key, map); 1029 jedis.close(); 1030 return s; 1031 } 1032 1033 /** 1034 * 添加对应关系，如果对应关系已存在，则覆盖 1035 * 1036 * @param Strin 1037 * key 1038 * @param Map 1039 * <String,String> 对应关系 1040 * @return 状态，成功返回OK 1041 */ 1042 public String hmset(byte[] key, Map<byte[], byte[]> map) { 1043 Jedis jedis = getJedis(); 1044 String s = jedis.hmset(key, map); 1045 jedis.close(); 1046 return s; 1047 } 1048 1049 } 1050 1051 // *******************************************Lists*******************************************// 1052 public class Lists { 1053 /** 1054 * List长度 1055 * 1056 * @param String 1057 * key 1058 * @return 长度 1059 */ 1060 public long llen(String key) { 1061 return llen(SafeEncoder.encode(key)); 1062 } 1063 1064 /** 1065 * List长度 1066 * 1067 * @param byte[] 1068 * key 1069 * @return 长度 1070 */ 1071 public long llen(byte[] key) { 1072 // ShardedJedis sjedis = getShardedJedis(); 1073 Jedis sjedis = getJedis(); 1074 long count = sjedis.llen(key); 1075 sjedis.close(); 1076 return count; 1077 } 1078 1079 /** 1080 * 覆盖操作,将覆盖List中指定位置的值 1081 * 1082 * @param byte[] 1083 * key 1084 * @param int 1085 * index 位置 1086 * @param byte[] 1087 * value 值 1088 * @return 状态码 1089 */ 1090 public String lset(byte[] key, int index, byte[] value) { 1091 Jedis jedis = getJedis(); 1092 String status = jedis.lset(key, index, value); 1093 jedis.close(); 1094 return status; 1095 } 1096 1097 /** 1098 * 覆盖操作,将覆盖List中指定位置的值 1099 * 1100 * @param key 1101 * @param int 1102 * index 位置 1103 * @param String 1104 * value 值 1105 * @return 状态码 1106 */ 1107 public String lset(String key, int index, String value) { 1108 return lset(SafeEncoder.encode(key), index, SafeEncoder.encode(value)); 1109 } 1110 1111 /** 1112 * 在value的相对位置插入记录 1113 * 1114 * @param key 1115 * @param LIST_POSITION 1116 * 前面插入或后面插入 1117 * @param String 1118 * pivot 相对位置的内容 1119 * @param String 1120 * value 插入的内容 1121 * @return 记录总数 1122 */ 1123 public long linsert(String key, LIST_POSITION where, String pivot, String value) { 1124 return linsert(SafeEncoder.encode(key), where, SafeEncoder.encode(pivot), SafeEncoder.encode(value)); 1125 } 1126 1127 /** 1128 * 在指定位置插入记录 1129 * 1130 * @param String 1131 * key 1132 * @param LIST_POSITION 1133 * 前面插入或后面插入 1134 * @param byte[] 1135 * pivot 相对位置的内容 1136 * @param byte[] 1137 * value 插入的内容 1138 * @return 记录总数 1139 */ 1140 public long linsert(byte[] key, LIST_POSITION where, byte[] pivot, byte[] value) { 1141 Jedis jedis = getJedis(); 1142 long count = jedis.linsert(key, where, pivot, value); 1143 jedis.close(); 1144 return count; 1145 } 1146 1147 /** 1148 * 获取List中指定位置的值 1149 * 1150 * @param String 1151 * key 1152 * @param int 1153 * index 位置 1154 * @return 值 1155 **/ 1156 public String lindex(String key, int index) { 1157 return SafeEncoder.encode(lindex(SafeEncoder.encode(key), index)); 1158 } 1159 1160 /** 1161 * 获取List中指定位置的值 1162 * 1163 * @param byte[] 1164 * key 1165 * @param int 1166 * index 位置 1167 * @return 值 1168 **/ 1169 public byte[] lindex(byte[] key, int index) { 1170 // ShardedJedis sjedis = getShardedJedis(); 1171 Jedis sjedis = getJedis(); 1172 byte[] value = sjedis.lindex(key, index); 1173 sjedis.close(); 1174 return value; 1175 } 1176 1177 /** 1178 * 将List中的第一条记录移出List 1179 * 1180 * @param String 1181 * key 1182 * @return 移出的记录 1183 */ 1184 public String lpop(String key) { 1185 return SafeEncoder.encode(lpop(SafeEncoder.encode(key))); 1186 } 1187 1188 /** 1189 * 将List中的第一条记录移出List 1190 * 1191 * @param byte[] 1192 * key 1193 * @return 移出的记录 1194 */ 1195 public byte[] lpop(byte[] key) { 1196 Jedis jedis = getJedis(); 1197 byte[] value = jedis.lpop(key); 1198 jedis.close(); 1199 return value; 1200 } 1201 1202 /** 1203 * 将List中最后第一条记录移出List 1204 * 1205 * @param byte[] 1206 * key 1207 * @return 移出的记录 1208 */ 1209 public String rpop(String key) { 1210 Jedis jedis = getJedis(); 1211 String value = jedis.rpop(key); 1212 jedis.close(); 1213 return value; 1214 } 1215 1216 /** 1217 * 向List尾部追加记录 1218 * 1219 * @param String 1220 * key 1221 * @param String 1222 * value 1223 * @return 记录总数 1224 */ 1225 public long lpush(String key, String value) { 1226 return lpush(SafeEncoder.encode(key), SafeEncoder.encode(value)); 1227 } 1228 1229 /** 1230 * 向List头部追加记录 1231 * 1232 * @param String 1233 * key 1234 * @param String 1235 * value 1236 * @return 记录总数 1237 */ 1238 public long rpush(String key, String value) { 1239 Jedis jedis = getJedis(); 1240 long count = jedis.rpush(key, value); 1241 jedis.close(); 1242 return count; 1243 } 1244 1245 /** 1246 * 向List头部追加记录 1247 * 1248 * @param String 1249 * key 1250 * @param String 1251 * value 1252 * @return 记录总数 1253 */ 1254 public long rpush(byte[] key, byte[] value) { 1255 Jedis jedis = getJedis(); 1256 long count = jedis.rpush(key, value); 1257 jedis.close(); 1258 return count; 1259 } 1260 1261 /** 1262 * 向List中追加记录 1263 * 1264 * @param byte[] 1265 * key 1266 * @param byte[] 1267 * value 1268 * @return 记录总数 1269 */ 1270 public long lpush(byte[] key, byte[] value) { 1271 Jedis jedis = getJedis(); 1272 long count = jedis.lpush(key, value); 1273 jedis.close(); 1274 return count; 1275 } 1276 1277 /** 1278 * 获取指定范围的记录，可以做为分页使用 1279 * 1280 * @param String 1281 * key 1282 * @param long 1283 * start 1284 * @param long 1285 * end 1286 * @return List 1287 */ 1288 public List<String> lrange(String key, long start, long end) { 1289 // ShardedJedis sjedis = getShardedJedis(); 1290 Jedis sjedis = getJedis(); 1291 List<String> list = sjedis.lrange(key, start, end); 1292 sjedis.close(); 1293 return list; 1294 } 1295 1296 /** 1297 * 获取指定范围的记录，可以做为分页使用 1298 * 1299 * @param byte[] 1300 * key 1301 * @param int 1302 * start 1303 * @param int 1304 * end 如果为负数，则尾部开始计算 1305 * @return List 1306 */ 1307 public List<byte[]> lrange(byte[] key, int start, int end) { 1308 // ShardedJedis sjedis = getShardedJedis(); 1309 Jedis sjedis = getJedis(); 1310 List<byte[]> list = sjedis.lrange(key, start, end); 1311 sjedis.close(); 1312 return list; 1313 } 1314 1315 /** 1316 * 删除List中c条记录，被删除的记录值为value 1317 * 1318 * @param byte[] 1319 * key 1320 * @param int 1321 * c 要删除的数量，如果为负数则从List的尾部检查并删除符合的记录 1322 * @param byte[] 1323 * value 要匹配的值 1324 * @return 删除后的List中的记录数 1325 */ 1326 public long lrem(byte[] key, int c, byte[] value) { 1327 Jedis jedis = getJedis(); 1328 long count = jedis.lrem(key, c, value); 1329 jedis.close(); 1330 return count; 1331 } 1332 1333 /** 1334 * 删除List中c条记录，被删除的记录值为value 1335 * 1336 * @param String 1337 * key 1338 * @param int 1339 * c 要删除的数量，如果为负数则从List的尾部检查并删除符合的记录 1340 * @param String 1341 * value 要匹配的值 1342 * @return 删除后的List中的记录数 1343 */ 1344 public long lrem(String key, int c, String value) { 1345 return lrem(SafeEncoder.encode(key), c, SafeEncoder.encode(value)); 1346 } 1347 1348 /** 1349 * 算是删除吧，只保留start与end之间的记录 1350 * 1351 * @param byte[] 1352 * key 1353 * @param int 1354 * start 记录的开始位置(0表示第一条记录) 1355 * @param int 1356 * end 记录的结束位置（如果为-1则表示最后一个，-2，-3以此类推） 1357 * @return 执行状态码 1358 */ 1359 public String ltrim(byte[] key, int start, int end) { 1360 Jedis jedis = getJedis(); 1361 String str = jedis.ltrim(key, start, end); 1362 jedis.close(); 1363 return str; 1364 } 1365 1366 /** 1367 * 算是删除吧，只保留start与end之间的记录 1368 * 1369 * @param String 1370 * key 1371 * @param int 1372 * start 记录的开始位置(0表示第一条记录) 1373 * @param int 1374 * end 记录的结束位置（如果为-1则表示最后一个，-2，-3以此类推） 1375 * @return 执行状态码 1376 */ 1377 public String ltrim(String key, int start, int end) { 1378 return ltrim(SafeEncoder.encode(key), start, end); 1379 } 1380 } 1381 1382 }
6、应用举例
先查redis是否有该key，若不存在，则从数据库里面取出相应数据，存到redis中；若存在，则从redis中取出来
1 @Service 2 public class AreaServiceImpl implements AreaService { 3 @Autowired 4 private AreaDao areaDao; 5 @Autowired 6 private JedisUtil.Keys jedisKeys; 7 @Autowired 8 private JedisUtil.Strings jedisStrings; 9 10 private static Logger logger = LoggerFactory.getLogger(AreaServiceImpl.class); 11 12 public static final String AREALISTKEY = "arealist"; 13 @Override 14 @Transactional 15 public List<Area> getAreaList() { 16 // 定义redis的key 17 String key = AREALISTKEY; 18 // 定义接收对象 19 List<Area> areaList = null; 20 // 定义jackson数据转换操作类 21 ObjectMapper mapper = new ObjectMapper(); 22 // 判断key是否存在 23 if (!jedisKeys.exists(key)) { 24 // 若不存在，则从数据库里面取出相应数据 25 areaList = areaDao.queryArea(); 26 // 将相关的实体类集合转换成string,存入redis里面对应的key中 27 String jsonString; 28 try { 29 jsonString = mapper.writeValueAsString(areaList); 30 } catch (JsonProcessingException e) { 31 e.printStackTrace(); 32 logger.error(e.getMessage()); 33 throw new AreaOperationException(e.getMessage()); 34 } 35 jedisStrings.set(key, jsonString); 36 } else { 37 // 若存在，则直接从redis里面取出相应数据 38 String jsonString = jedisStrings.get(key); 39 // 指定要将string转换成的集合类型 40 JavaType javaType = mapper.getTypeFactory().constructParametricType(ArrayList.class, Area.class); 41 try { 42 // 将相关key对应的value里的的string转换成对象的实体类集合 43 areaList = mapper.readValue(jsonString, javaType); 44 } catch (JsonParseException e) { 45 e.printStackTrace(); 46 logger.error(e.getMessage()); 47 throw new AreaOperationException(e.getMessage()); 48 } catch (JsonMappingException e) { 49 e.printStackTrace(); 50 logger.error(e.getMessage()); 51 throw new AreaOperationException(e.getMessage()); 52 } catch (IOException e) { 53 e.printStackTrace(); 54 logger.error(e.getMessage()); 55 throw new AreaOperationException(e.getMessage()); 56 } 57 } 58 return areaList; 59 } 60 61 }