Lettuce 和 Jedis 的定位都是Redis的client，所以他们当然可以直接连接redis server。
pring boot框架中已经集成了redis，在1.x.x的版本时默认使用的jedis客户端，现在是2.x.x版本默认使用的lettuce客户端。
Jedis
Jedis在实现上是直接连接的redis server，如果在多线程环境下是非线程安全的，这个时候只有使用连接池，为每个Jedis实例增加物理连接
Lettuce
Lettuce的连接是基于Netty的，连接实例（StatefulRedisConnection）可以在多个线程间并发访问，应为StatefulRedisConnection是线程安全的，所以一个连接实例（StatefulRedisConnection）就可以满足多线程环境下的并发访问，当然这个也是可伸缩的设计，一个连接实例不够的情况也可以按需增加连接实例。
lettuce主要利用netty实现与redis的同步和异步通信。
转载链接：https://blog.csdn.net/weixin_37264997/article/details/90026602
SpringBoot集成Jedis：
1 <dependency> 2 <groupId>org.springframework.boot</groupId> 3 <artifactId>spring-boot-starter-data-redis</artifactId> 4 </dependency> 5 6 <dependency> 7 <groupId>redis.clients</groupId> 8 <artifactId>jedis</artifactId> 9 <version>2.9.0</version> 10 </dependency>
JedisConfig配置类
1 import lombok.extern.slf4j.Slf4j; 2 import org.springframework.beans.factory.annotation.Value; 3 import org.springframework.context.annotation.Bean; 4 import org.springframework.context.annotation.Configuration; 5 import redis.clients.jedis.JedisPool; 6 import redis.clients.jedis.JedisPoolConfig; 7 8 @Configuration 9 @Slf4j 10 public class JedisConfig { 11 12 @Value("${spring.redis.host}") 13 private String host; 14 15 @Value("${spring.redis.port}") 16 private int port; 17 18 @Value("${spring.redis.timeout}") 19 private int timeout; 20 21 @Value("${spring.redis.jedis.pool.max-idle}") 22 private int maxIdle; 23 24 @Value("${spring.redis.jedis.pool.max-wait}") 25 private long maxWaitMillis; 26 27 @Value("${spring.redis.password}") 28 private String password; 29 30 @Value("${spring.redis.block-when-exhausted}") 31 private boolean blockWhenExhausted; 32 33 @Bean 34 public JedisPool redisPoolFactory() throws Exception{ 35 log.info("JedisPool注入成功！！"); 36 log.info("redis地址：" + host + ":" + port); 37 JedisPoolConfig jedisPoolConfig = new JedisPoolConfig(); 38 jedisPoolConfig.setMaxIdle(maxIdle); 39 jedisPoolConfig.setMaxWaitMillis(maxWaitMillis); 40 // 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true 41 jedisPoolConfig.setBlockWhenExhausted(blockWhenExhausted); 42 // 是否启用pool的jmx管理功能, 默认true 43 jedisPoolConfig.setJmxEnabled(true); 44 /** 45 * 這裏password參數填null，不然會報錯(jedis連接數據庫沒設置密碼填null,填其他回報這個錯)： 46 * Caused by: redis.clients.jedis.exceptions.JedisDataException: ERR Client sent AUTH, but no password is set 47 */ 48 JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, null); 49 return jedisPool; 50 } 51 52 }
SerializeUtil
1 import lombok.extern.slf4j.Slf4j; 2 import org.springframework.stereotype.Component; 3 import java.io.*; 4 5 @Component 6 @Slf4j 7 public class SerializeUtil { 8 9 // 序列化 10 public static byte[] serialize(Object object) { 11 12 ObjectOutputStream oos = null; 13 ByteArrayOutputStream baos = null; 14 byte[] bytes = null; 15 try { 16 baos = new ByteArrayOutputStream(); 17 oos = new ObjectOutputStream(baos); 18 oos.writeObject(object); 19 bytes = baos.toByteArray(); 20 } catch (Exception e) { 21 System.err.println("序列化失败" + e.getMessage()); 22 } 23 return bytes; 24 } 25 26 // 反序列化 27 public static Object deserialize(byte[] bytes) throws IOException, ClassNotFoundException { 28 29 ByteArrayInputStream bais = null; 30 ObjectInputStream ois = null; 31 try { 32 bais = new ByteArrayInputStream(bytes); 33 ois = new ObjectInputStream(bais); 34 } catch (Exception e) { 35 System.err.println("反序列化失败" + e.getMessage()); 36 } 37 return ois.readObject(); 38 } 39 40 }
JedisUtil
1 package com.example.redis.util; 2 3 import lombok.extern.slf4j.Slf4j; 4 import org.springframework.stereotype.Component; 5 import java.io.ByteArrayInputStream; 6 import java.io.ByteArrayOutputStream; 7 import java.io.ObjectInputStream; 8 import java.io.ObjectOutputStream; 9 import java.util.List; 10 import java.util.Map; 11 import java.util.Set; 12 import org.springframework.beans.factory.annotation.Autowired; 13 import redis.clients.jedis.BinaryClient.LIST_POSITION; 14 import redis.clients.jedis.Jedis; 15 import redis.clients.jedis.JedisPool; 16 import redis.clients.jedis.SortingParams; 17 18 @Component 19 @Slf4j 20 public class JedisUtil { 21 22 @Autowired 23 private JedisPool jedisPool; 24 25 /** 26 * 通过key获取储存在redis中的value 27 * 并释放连接 28 * @param key 29 * @param indexdb 选择redis库 0-15 30 * @return 成功返回value 失败返回null 31 */ 32 public String get(String key,int indexdb) { 33 Jedis jedis = null; 34 String value = null; 35 try { 36 jedis = jedisPool.getResource(); 37 jedis.select(indexdb); 38 value = jedis.get(key); 39 log.info(value); 40 } catch (Exception e) { 41 42 log.error(e.getMessage()); 43 } finally { 44 returnResource(jedisPool, jedis); 45 } 46 return value; 47 } 48 49 /** 50 * 通过key获取储存在redis中的value 51 * 并释放连接 52 * @param key 53 * @param indexdb 选择redis库 0-15 54 * @return 成功返回value 失败返回null 55 */ 56 public byte[] get(byte[] key,int indexdb) { 57 Jedis jedis = null; 58 byte[] value = null; 59 try { 60 jedis = jedisPool.getResource(); 61 jedis.select(indexdb); 62 value = jedis.get(key); 63 } catch (Exception e) { 64 65 log.error(e.getMessage()); 66 } finally { 67 returnResource(jedisPool, jedis); 68 } 69 return value; 70 } 71 /** 72 * 向redis存入key和value,并释放连接资源 73 * 如果key已经存在 则覆盖 74 * @param key 75 * @param value 76 * @param indexdb 选择redis库 0-15 77 * @return 成功 返回OK 失败返回 0 78 */ 79 public String set(String key, String value,int indexdb) { 80 Jedis jedis = null; 81 try { 82 jedis = jedisPool.getResource(); 83 jedis.select(indexdb); 84 return jedis.set(key, value); 85 } catch (Exception e) { 86 87 log.error(e.getMessage()); 88 return "0"; 89 } finally { 90 returnResource(jedisPool, jedis); 91 } 92 } 93 /** 94 * 向redis存入key和value,并释放连接资源 95 * 如果key已经存在 则覆盖 96 * @param key 97 * @param value 98 * @param indexdb 选择redis库 0-15 99 * @return 成功 返回OK 失败返回 0 100 */ 101 public String set(byte[] key, byte[] value,int indexdb) { 102 Jedis jedis = null; 103 try { 104 jedis = jedisPool.getResource(); 105 jedis.select(indexdb); 106 return jedis.set(key, value); 107 } catch (Exception e) { 108 109 log.error(e.getMessage()); 110 return "0"; 111 } finally { 112 returnResource(jedisPool, jedis); 113 } 114 } 115 /** 116 * 删除指定的key,也可以传入一个包含key的数组 117 * @param keys 一个key 也可以使 string 数组 118 * @return 返回删除成功的个数 119 */ 120 public Long del(String... keys) { 121 Jedis jedis = null; 122 try { 123 jedis = jedisPool.getResource(); 124 return jedis.del(keys); 125 } catch (Exception e) { 126 127 log.error(e.getMessage()); 128 return 0L; 129 } finally { 130 returnResource(jedisPool, jedis); 131 } 132 } 133 /** 134 * 删除指定的key,也可以传入一个包含key的数组 135 * @param indexdb 选择redis库 0-15 136 * @param keys 一个key 也可以使 string 数组 137 * @return 返回删除成功的个数 138 */ 139 public Long del(int indexdb,String... keys) { 140 Jedis jedis = null; 141 try { 142 jedis = jedisPool.getResource(); 143 jedis.select(indexdb); 144 return jedis.del(keys); 145 } catch (Exception e) { 146 147 log.error(e.getMessage()); 148 return 0L; 149 } finally { 150 returnResource(jedisPool, jedis); 151 } 152 } 153 /** 154 * 删除指定的key,也可以传入一个包含key的数组 155 * @param indexdb 选择redis库 0-15 156 * @param keys 一个key 也可以使 string 数组 157 * @return 返回删除成功的个数 158 */ 159 public Long del(int indexdb,byte[]... keys) { 160 Jedis jedis = null; 161 try { 162 jedis = jedisPool.getResource(); 163 jedis.select(indexdb); 164 return jedis.del(keys); 165 } catch (Exception e) { 166 167 log.error(e.getMessage()); 168 return 0L; 169 } finally { 170 returnResource(jedisPool, jedis); 171 } 172 } 173 /** 174 * 通过key向指定的value值追加值 175 * @param key 176 * @param str 177 * @return 成功返回 添加后value的长度 失败 返回 添加的 value 的长度 异常返回0L 178 */ 179 public Long append(String key, String str) { 180 Jedis jedis = null; 181 Long res = null; 182 try { 183 jedis = jedisPool.getResource(); 184 res = jedis.append(key, str); 185 } catch (Exception e) { 186 187 log.error(e.getMessage()); 188 return 0L; 189 } finally { 190 returnResource(jedisPool, jedis); 191 } 192 return res; 193 } 194 195 /** 196 * 判断key是否存在 197 * @param key 198 * @return true OR false 199 */ 200 public Boolean exists(String key) { 201 Jedis jedis = null; 202 try { 203 jedis = jedisPool.getResource(); 204 return jedis.exists(key); 205 } catch (Exception e) { 206 207 log.error(e.getMessage()); 208 return false; 209 } finally { 210 returnResource(jedisPool, jedis); 211 } 212 } 213 214 /** 215 * 清空当前数据库中的所有 key,此命令从不失败。 216 * @return 总是返回 OK 217 */ 218 public String flushDB() { 219 Jedis jedis = null; 220 try { 221 jedis = jedisPool.getResource(); 222 return jedis.flushDB(); 223 } catch (Exception e) { 224 log.error(e.getMessage()); 225 } finally { 226 returnResource(jedisPool, jedis); 227 } 228 return null; 229 } 230 231 /** 232 * 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。 233 * @param key 234 * @param value 235 * 过期时间，单位：秒 236 * @return 成功返回1 如果存在 和 发生异常 返回 0 237 */ 238 public Long expire(String key, int value, int indexdb) { 239 Jedis jedis = null; 240 try { 241 jedis = jedisPool.getResource(); 242 jedis.select(indexdb); 243 return jedis.expire(key, value); 244 } catch (Exception e) { 245 log.error(e.getMessage()); 246 return 0L; 247 } finally { 248 returnResource(jedisPool, jedis); 249 } 250 } 251 252 /** 253 * <p> 254 * 以秒为单位，返回给定 key 的剩余生存时间 255 * </p> 256 * 257 * @param key 258 * @return 当 key 不存在时，返回 -2 。当 key 存在但没有设置剩余生存时间时，返回 -1 。否则，以秒为单位，返回 key 259 * 的剩余生存时间。 发生异常 返回 0 260 */ 261 public Long ttl(String key,int indexdb) { 262 Jedis jedis = null; 263 try { 264 jedis = jedisPool.getResource(); 265 jedis.select(indexdb); 266 return jedis.ttl(key); 267 } catch (Exception e) { 268 269 log.error(e.getMessage()); 270 return 0L; 271 } finally { 272 returnResource(jedisPool, jedis); 273 } 274 } 275 276 /** 277 * <p> 278 * 移除给定 key 的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key ) 279 * </p> 280 * 281 * @param key 282 * @return 当生存时间移除成功时，返回 1 .如果 key 不存在或 key 没有设置生存时间，返回 0 ， 发生异常 返回 -1 283 */ 284 public Long persist(String key) { 285 Jedis jedis = null; 286 try { 287 jedis = jedisPool.getResource(); 288 return jedis.persist(key); 289 } catch (Exception e) { 290 291 log.error(e.getMessage()); 292 return -1L; 293 } finally { 294 returnResource(jedisPool, jedis); 295 } 296 } 297 298 /** 299 * <p> 300 * 新增key,并将 key 的生存时间 (以秒为单位) 301 * </p> 302 * 303 * @param key 304 * @param seconds 305 * 生存时间 单位：秒 306 * @param value 307 * @return 设置成功时返回 OK 。当 seconds 参数不合法时，返回一个错误。 308 */ 309 public String setex(String key, int seconds, String value) { 310 Jedis jedis = null; 311 try { 312 jedis = jedisPool.getResource(); 313 return jedis.setex(key, seconds, value); 314 } catch (Exception e) { 315 316 log.error(e.getMessage()); 317 } finally { 318 returnResource(jedisPool, jedis); 319 } 320 return null; 321 } 322 323 /** 324 * <p> 325 * 设置key value,如果key已经存在则返回0,nx==> not exist 326 * </p> 327 * 328 * @param key 329 * @param value 330 * @return 成功返回1 如果存在 和 发生异常 返回 0 331 */ 332 public Long setnx(String key, String value) { 333 Jedis jedis = null; 334 try { 335 jedis = jedisPool.getResource(); 336 return jedis.setnx(key, value); 337 } catch (Exception e) { 338 339 log.error(e.getMessage()); 340 return 0L; 341 } finally { 342 returnResource(jedisPool, jedis); 343 } 344 } 345 346 /** 347 * <p> 348 * 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。 349 * </p> 350 * <p> 351 * 当 key 存在但不是字符串类型时，返回一个错误。 352 * </p> 353 * 354 * @param key 355 * @param value 356 * @return 返回给定 key 的旧值。当 key 没有旧值时，也即是， key 不存在时，返回 nil 357 */ 358 public String getSet(String key, String value) { 359 Jedis jedis = null; 360 try { 361 jedis = jedisPool.getResource(); 362 return jedis.getSet(key, value); 363 } catch (Exception e) { 364 365 log.error(e.getMessage()); 366 } finally { 367 returnResource(jedisPool, jedis); 368 } 369 return null; 370 } 371 372 /** 373 * <p> 374 * 设置key value并制定这个键值的有效期 375 * </p> 376 * 377 * @param key 378 * @param value 379 * @param seconds 380 * 单位:秒 381 * @return 成功返回OK 失败和异常返回null 382 */ 383 public String setex(String key, String value, int seconds) { 384 Jedis jedis = null; 385 String res = null; 386 try { 387 jedis = jedisPool.getResource(); 388 res = jedis.setex(key, seconds, value); 389 } catch (Exception e) { 390 391 log.error(e.getMessage()); 392 } finally { 393 returnResource(jedisPool, jedis); 394 } 395 return res; 396 } 397 398 /** 399 * <p> 400 * 通过key 和offset 从指定的位置开始将原先value替换 401 * </p> 402 * <p> 403 * 下标从0开始,offset表示从offset下标开始替换 404 * </p> 405 * <p> 406 * 如果替换的字符串长度过小则会这样 407 * </p> 408 * <p> 409 * example: 410 * </p> 411 * <p> 412 * value : bigsea@zto.cn 413 * </p> 414 * <p> 415 * str : abc 416 * </p> 417 * <P> 418 * 从下标7开始替换 则结果为 419 * </p> 420 * <p> 421 * RES : bigsea.abc.cn 422 * </p> 423 * 424 * @param key 425 * @param str 426 * @param offset 427 * 下标位置 428 * @return 返回替换后 value 的长度 429 */ 430 public Long setrange(String key, String str, int offset) { 431 Jedis jedis = null; 432 try { 433 jedis = jedisPool.getResource(); 434 return jedis.setrange(key, offset, str); 435 } catch (Exception e) { 436 437 log.error(e.getMessage()); 438 return 0L; 439 } finally { 440 returnResource(jedisPool, jedis); 441 } 442 } 443 444 /** 445 * <p> 446 * 通过批量的key获取批量的value 447 * </p> 448 * 449 * @param keys 450 * string数组 也可以是一个key 451 * @return 成功返回value的集合, 失败返回null的集合 ,异常返回空 452 */ 453 public List<String> mget(String... keys) { 454 Jedis jedis = null; 455 List<String> values = null; 456 try { 457 jedis = jedisPool.getResource(); 458 values = jedis.mget(keys); 459 } catch (Exception e) { 460 461 log.error(e.getMessage()); 462 } finally { 463 returnResource(jedisPool, jedis); 464 } 465 return values; 466 } 467 468 /** 469 * <p> 470 * 批量的设置key:value,可以一个 471 * </p> 472 * <p> 473 * example: 474 * </p> 475 * <p> 476 * obj.mset(new String[]{"key2","value1","key2","value2"}) 477 * </p> 478 * 479 * @param keysvalues 480 * @return 成功返回OK 失败 异常 返回 null 481 * 482 */ 483 public String mset(String... keysvalues) { 484 Jedis jedis = null; 485 String res = null; 486 try { 487 jedis = jedisPool.getResource(); 488 res = jedis.mset(keysvalues); 489 } catch (Exception e) { 490 491 log.error(e.getMessage()); 492 } finally { 493 returnResource(jedisPool, jedis); 494 } 495 return res; 496 } 497 498 /** 499 * <p> 500 * 批量的设置key:value,可以一个,如果key已经存在则会失败,操作会回滚 501 * </p> 502 * <p> 503 * example: 504 * </p> 505 * <p> 506 * obj.msetnx(new String[]{"key2","value1","key2","value2"}) 507 * </p> 508 * 509 * @param keysvalues 510 * @return 成功返回1 失败返回0 511 */ 512 public Long msetnx(String... keysvalues) { 513 Jedis jedis = null; 514 Long res = 0L; 515 try { 516 jedis = jedisPool.getResource(); 517 res = jedis.msetnx(keysvalues); 518 } catch (Exception e) { 519 520 log.error(e.getMessage()); 521 } finally { 522 returnResource(jedisPool, jedis); 523 } 524 return res; 525 } 526 527 /** 528 * <p> 529 * 设置key的值,并返回一个旧值 530 * </p> 531 * 532 * @param key 533 * @param value 534 * @return 旧值 如果key不存在 则返回null 535 */ 536 public String getset(String key, String value) { 537 Jedis jedis = null; 538 String res = null; 539 try { 540 jedis = jedisPool.getResource(); 541 res = jedis.getSet(key, value); 542 } catch (Exception e) { 543 544 log.error(e.getMessage()); 545 } finally { 546 returnResource(jedisPool, jedis); 547 } 548 return res; 549 } 550 551 /** 552 * <p> 553 * 通过下标 和key 获取指定下标位置的 value 554 * </p> 555 * 556 * @param key 557 * @param startOffset 558 * 开始位置 从0 开始 负数表示从右边开始截取 559 * @param endOffset 560 * @return 如果没有返回null 561 */ 562 public String getrange(String key, int startOffset, int endOffset) { 563 Jedis jedis = null; 564 String res = null; 565 try { 566 jedis = jedisPool.getResource(); 567 res = jedis.getrange(key, startOffset, endOffset); 568 } catch (Exception e) { 569 570 log.error(e.getMessage()); 571 } finally { 572 returnResource(jedisPool, jedis); 573 } 574 return res; 575 } 576 577 /** 578 * <p> 579 * 通过key 对value进行加值+1操作,当value不是int类型时会返回错误,当key不存在是则value为1 580 * </p> 581 * 582 * @param key 583 * @return 加值后的结果 584 */ 585 public Long incr(String key) { 586 Jedis jedis = null; 587 Long res = null; 588 try { 589 jedis = jedisPool.getResource(); 590 res = jedis.incr(key); 591 } catch (Exception e) { 592 593 log.error(e.getMessage()); 594 } finally { 595 returnResource(jedisPool, jedis); 596 } 597 return res; 598 } 599 600 /** 601 * <p> 602 * 通过key给指定的value加值,如果key不存在,则这是value为该值 603 * </p> 604 * 605 * @param key 606 * @param integer 607 * @return 608 */ 609 public Long incrBy(String key, Long integer) { 610 Jedis jedis = null; 611 Long res = null; 612 try { 613 jedis = jedisPool.getResource(); 614 res = jedis.incrBy(key, integer); 615 } catch (Exception e) { 616 617 log.error(e.getMessage()); 618 } finally { 619 returnResource(jedisPool, jedis); 620 } 621 return res; 622 } 623 624 /** 625 * <p> 626 * 对key的值做减减操作,如果key不存在,则设置key为-1 627 * </p> 628 * 629 * @param key 630 * @return 631 */ 632 public Long decr(String key) { 633 Jedis jedis = null; 634 Long res = null; 635 try { 636 jedis = jedisPool.getResource(); 637 res = jedis.decr(key); 638 } catch (Exception e) { 639 640 log.error(e.getMessage()); 641 } finally { 642 returnResource(jedisPool, jedis); 643 } 644 return res; 645 } 646 647 /** 648 * <p> 649 * 减去指定的值 650 * </p> 651 * 652 * @param key 653 * @param integer 654 * @return 655 */ 656 public Long decrBy(String key, Long integer) { 657 Jedis jedis = null; 658 Long res = null; 659 try { 660 jedis = jedisPool.getResource(); 661 res = jedis.decrBy(key, integer); 662 } catch (Exception e) { 663 664 log.error(e.getMessage()); 665 } finally { 666 returnResource(jedisPool, jedis); 667 } 668 return res; 669 } 670 671 /** 672 * <p> 673 * 通过key获取value值的长度 674 * </p> 675 * 676 * @param key 677 * @return 失败返回null 678 */ 679 public Long serlen(String key) { 680 Jedis jedis = null; 681 Long res = null; 682 try { 683 jedis = jedisPool.getResource(); 684 res = jedis.strlen(key); 685 } catch (Exception e) { 686 687 log.error(e.getMessage()); 688 } finally { 689 returnResource(jedisPool, jedis); 690 } 691 return res; 692 } 693 694 /** 695 * <p> 696 * 通过key给field设置指定的值,如果key不存在,则先创建 697 * </p> 698 * 699 * @param key 700 * @param field 701 * 字段 702 * @param value 703 * @return 如果存在返回0 异常返回null 704 */ 705 public Long hset(String key, String field, String value) { 706 Jedis jedis = null; 707 Long res = null; 708 try { 709 jedis = jedisPool.getResource(); 710 res = jedis.hset(key, field, value); 711 } catch (Exception e) { 712 713 log.error(e.getMessage()); 714 } finally { 715 returnResource(jedisPool, jedis); 716 } 717 return res; 718 } 719 720 /** 721 * <p> 722 * 通过key给field设置指定的值,如果key不存在则先创建,如果field已经存在,返回0 723 * </p> 724 * 725 * @param key 726 * @param field 727 * @param value 728 * @return 729 */ 730 public Long hsetnx(String key, String field, String value) { 731 Jedis jedis = null; 732 Long res = null; 733 try { 734 jedis = jedisPool.getResource(); 735 res = jedis.hsetnx(key, field, value); 736 } catch (Exception e) { 737 738 log.error(e.getMessage()); 739 } finally { 740 returnResource(jedisPool, jedis); 741 } 742 return res; 743 } 744 745 /** 746 * <p> 747 * 通过key同时设置 hash的多个field 748 * </p> 749 * 750 * @param key 751 * @param hash 752 * @return 返回OK 异常返回null 753 */ 754 public String hmset(String key, Map<String, String> hash, int indexdb) { 755 Jedis jedis = null; 756 String res = null; 757 try { 758 jedis = jedisPool.getResource(); 759 jedis.select(indexdb); 760 res = jedis.hmset(key, hash); 761 } catch (Exception e) { 762 763 log.error(e.getMessage()); 764 } finally { 765 returnResource(jedisPool, jedis); 766 } 767 return res; 768 } 769 770 /** 771 * <p> 772 * 通过key 和 field 获取指定的 value 773 * </p> 774 * 775 * @param key 776 * @param field 777 * @return 没有返回null 778 */ 779 public String hget(String key, String field) { 780 Jedis jedis = null; 781 String res = null; 782 try { 783 jedis = jedisPool.getResource(); 784 res = jedis.hget(key, field); 785 } catch (Exception e) { 786 787 log.error(e.getMessage()); 788 } finally { 789 returnResource(jedisPool, jedis); 790 } 791 return res; 792 } 793 794 /** 795 * <p> 796 * 通过key 和 fields 获取指定的value 如果没有对应的value则返回null 797 * </p> 798 * 799 * @param key 800 * @param fields 801 * 可以使 一个String 也可以是 String数组 802 * @return 803 */ 804 public List<String> hmget(String key, int indexdb, String... fields) { 805 Jedis jedis = null; 806 List<String> res = null; 807 try { 808 jedis = jedisPool.getResource(); 809 jedis.select(indexdb); 810 res = jedis.hmget(key, fields); 811 } catch (Exception e) { 812 813 log.error(e.getMessage()); 814 } finally { 815 returnResource(jedisPool, jedis); 816 } 817 return res; 818 } 819 820 /** 821 * <p> 822 * 通过key给指定的field的value加上给定的值 823 * </p> 824 * 825 * @param key 826 * @param field 827 * @param value 828 * @return 829 */ 830 public Long hincrby(String key, String field, Long value) { 831 Jedis jedis = null; 832 Long res = null; 833 try { 834 jedis = jedisPool.getResource(); 835 res = jedis.hincrBy(key, field, value); 836 } catch (Exception e) { 837 838 log.error(e.getMessage()); 839 } finally { 840 returnResource(jedisPool, jedis); 841 } 842 return res; 843 } 844 845 /** 846 * <p> 847 * 通过key和field判断是否有指定的value存在 848 * </p> 849 * 850 * @param key 851 * @param field 852 * @return 853 */ 854 public Boolean hexists(String key, String field) { 855 Jedis jedis = null; 856 Boolean res = false; 857 try { 858 jedis = jedisPool.getResource(); 859 res = jedis.hexists(key, field); 860 } catch (Exception e) { 861 862 log.error(e.getMessage()); 863 } finally { 864 returnResource(jedisPool, jedis); 865 } 866 return res; 867 } 868 869 /** 870 * <p> 871 * 通过key返回field的数量 872 * </p> 873 * 874 * @param key 875 * @return 876 */ 877 public Long hlen(String key) { 878 Jedis jedis = null; 879 Long res = null; 880 try { 881 jedis = jedisPool.getResource(); 882 res = jedis.hlen(key); 883 } catch (Exception e) { 884 885 log.error(e.getMessage()); 886 } finally { 887 returnResource(jedisPool, jedis); 888 } 889 return res; 890 891 } 892 893 /** 894 * <p> 895 * 通过key 删除指定的 field 896 * </p> 897 * 898 * @param key 899 * @param fields 900 * 可以是 一个 field 也可以是 一个数组 901 * @return 902 */ 903 public Long hdel(String key, String... fields) { 904 Jedis jedis = null; 905 Long res = null; 906 try { 907 jedis = jedisPool.getResource(); 908 res = jedis.hdel(key, fields); 909 } catch (Exception e) { 910 911 log.error(e.getMessage()); 912 } finally { 913 returnResource(jedisPool, jedis); 914 } 915 return res; 916 } 917 918 /** 919 * <p> 920 * 通过key返回所有的field 921 * </p> 922 * 923 * @param key 924 * @return 925 */ 926 public Set<String> hkeys(String key) { 927 Jedis jedis = null; 928 Set<String> res = null; 929 try { 930 jedis = jedisPool.getResource(); 931 res = jedis.hkeys(key); 932 } catch (Exception e) { 933 934 log.error(e.getMessage()); 935 } finally { 936 returnResource(jedisPool, jedis); 937 } 938 return res; 939 } 940 941 /** 942 * <p> 943 * 通过key返回所有和key有关的value 944 * </p> 945 * 946 * @param key 947 * @return 948 */ 949 public List<String> hvals(String key) { 950 Jedis jedis = null; 951 List<String> res = null; 952 try { 953 jedis = jedisPool.getResource(); 954 res = jedis.hvals(key); 955 } catch (Exception e) { 956 957 log.error(e.getMessage()); 958 } finally { 959 returnResource(jedisPool, jedis); 960 } 961 return res; 962 } 963 964 /** 965 * <p> 966 * 通过key获取所有的field和value 967 * </p> 968 * 969 * @param key 970 * @return 971 */ 972 public Map<String, String> hgetall(String key, int indexdb) { 973 Jedis jedis = null; 974 Map<String, String> res = null; 975 try { 976 jedis = jedisPool.getResource(); 977 jedis.select(indexdb); 978 res = jedis.hgetAll(key); 979 } catch (Exception e) { 980 log.error(e.getMessage()); 981 } finally { 982 returnResource(jedisPool, jedis); 983 } 984 return res; 985 } 986 987 /** 988 * <p> 989 * 通过key向list头部添加字符串 990 * </p> 991 * 992 * @param key 993 * @param strs 994 * 可以使一个string 也可以使string数组 995 * @return 返回list的value个数 996 */ 997 public Long lpush(int indexdb, String key, String... strs) { 998 Jedis jedis = null; 999 Long res = null; 1000 try { 1001 jedis = jedisPool.getResource(); 1002 jedis.select(indexdb); 1003 res = jedis.lpush(key, strs); 1004 } catch (Exception e) { 1005 1006 log.error(e.getMessage()); 1007 } finally { 1008 returnResource(jedisPool, jedis); 1009 } 1010 return res; 1011 } 1012 1013 /** 1014 * <p> 1015 * 通过key向list尾部添加字符串 1016 * </p> 1017 * 1018 * @param key 1019 * @param strs 1020 * 可以使一个string 也可以使string数组 1021 * @return 返回list的value个数 1022 */ 1023 public Long rpush(String key, String... strs) { 1024 Jedis jedis = null; 1025 Long res = null; 1026 try { 1027 jedis = jedisPool.getResource(); 1028 res = jedis.rpush(key, strs); 1029 } catch (Exception e) { 1030 1031 log.error(e.getMessage()); 1032 } finally { 1033 returnResource(jedisPool, jedis); 1034 } 1035 return res; 1036 } 1037 1038 /** 1039 * <p> 1040 * 通过key在list指定的位置之前或者之后 添加字符串元素 1041 * </p> 1042 * 1043 * @param key 1044 * @param where 1045 * LIST_POSITION枚举类型 1046 * @param pivot 1047 * list里面的value 1048 * @param value 1049 * 添加的value 1050 * @return 1051 */ 1052 public Long linsert(String key, LIST_POSITION where, String pivot, 1053 String value) { 1054 Jedis jedis = null; 1055 Long res = null; 1056 try { 1057 jedis = jedisPool.getResource(); 1058 res = jedis.linsert(key, where, pivot, value); 1059 } catch (Exception e) { 1060 1061 log.error(e.getMessage()); 1062 } finally { 1063 returnResource(jedisPool, jedis); 1064 } 1065 return res; 1066 } 1067 1068 /** 1069 * <p> 1070 * 通过key设置list指定下标位置的value 1071 * </p> 1072 * <p> 1073 * 如果下标超过list里面value的个数则报错 1074 * </p> 1075 * 1076 * @param key 1077 * @param index 1078 * 从0开始 1079 * @param value 1080 * @return 成功返回OK 1081 */ 1082 public String lset(String key, Long index, String value) { 1083 Jedis jedis = null; 1084 String res = null; 1085 try { 1086 jedis = jedisPool.getResource(); 1087 res = jedis.lset(key, index, value); 1088 } catch (Exception e) { 1089 1090 log.error(e.getMessage()); 1091 } finally { 1092 returnResource(jedisPool, jedis); 1093 } 1094 return res; 1095 } 1096 1097 /** 1098 * <p> 1099 * 通过key从对应的list中删除指定的count个 和 value相同的元素 1100 * </p> 1101 * 1102 * @param key 1103 * @param count 1104 * 当count为0时删除全部 1105 * @param value 1106 * @return 返回被删除的个数 1107 */ 1108 public Long lrem(String key, long count, String value) { 1109 Jedis jedis = null; 1110 Long res = null; 1111 try { 1112 jedis = jedisPool.getResource(); 1113 res = jedis.lrem(key, count, value); 1114 } catch (Exception e) { 1115 1116 log.error(e.getMessage()); 1117 } finally { 1118 returnResource(jedisPool, jedis); 1119 } 1120 return res; 1121 } 1122 1123 /** 1124 * <p> 1125 * 通过key保留list中从strat下标开始到end下标结束的value值 1126 * </p> 1127 * 1128 * @param key 1129 * @param start 1130 * @param end 1131 * @return 成功返回OK 1132 */ 1133 public String ltrim(String key, long start, long end) { 1134 Jedis jedis = null; 1135 String res = null; 1136 try { 1137 jedis = jedisPool.getResource(); 1138 res = jedis.ltrim(key, start, end); 1139 } catch (Exception e) { 1140 1141 log.error(e.getMessage()); 1142 } finally { 1143 returnResource(jedisPool, jedis); 1144 } 1145 return res; 1146 } 1147 1148 /** 1149 * <p> 1150 * 通过key从list的头部删除一个value,并返回该value 1151 * </p> 1152 * 1153 * @param key 1154 * @return 1155 */ 1156 synchronized public String lpop(String key) { 1157 Jedis jedis = null; 1158 String res = null; 1159 try { 1160 jedis = jedisPool.getResource(); 1161 res = jedis.lpop(key); 1162 } catch (Exception e) { 1163 1164 log.error(e.getMessage()); 1165 } finally { 1166 returnResource(jedisPool, jedis); 1167 } 1168 return res; 1169 } 1170 1171 /** 1172 * <p> 1173 * 通过key从list尾部删除一个value,并返回该元素 1174 * </p> 1175 * 1176 * @param key 1177 * @return 1178 */ 1179 synchronized public String rpop(String key, int indexdb) { 1180 Jedis jedis = null; 1181 String res = null; 1182 try { 1183 jedis = jedisPool.getResource(); 1184 jedis.select(indexdb); 1185 res = jedis.rpop(key); 1186 } catch (Exception e) { 1187 1188 log.error(e.getMessage()); 1189 } finally { 1190 returnResource(jedisPool, jedis); 1191 } 1192 return res; 1193 } 1194 1195 /** 1196 * <p> 1197 * 通过key从一个list的尾部删除一个value并添加到另一个list的头部,并返回该value 1198 * </p> 1199 * <p> 1200 * 如果第一个list为空或者不存在则返回null 1201 * </p> 1202 * 1203 * @param srckey 1204 * @param dstkey 1205 * @return 1206 */ 1207 public String rpoplpush(String srckey, String dstkey, int indexdb) { 1208 Jedis jedis = null; 1209 String res = null; 1210 try { 1211 jedis = jedisPool.getResource(); 1212 jedis.select(indexdb); 1213 res = jedis.rpoplpush(srckey, dstkey); 1214 } catch (Exception e) { 1215 1216 log.error(e.getMessage()); 1217 } finally { 1218 returnResource(jedisPool, jedis); 1219 } 1220 return res; 1221 } 1222 1223 /** 1224 * <p> 1225 * 通过key获取list中指定下标位置的value 1226 * </p> 1227 * 1228 * @param key 1229 * @param index 1230 * @return 如果没有返回null 1231 */ 1232 public String lindex(String key, long index) { 1233 Jedis jedis = null; 1234 String res = null; 1235 try { 1236 jedis = jedisPool.getResource(); 1237 res = jedis.lindex(key, index); 1238 } catch (Exception e) { 1239 1240 log.error(e.getMessage()); 1241 } finally { 1242 returnResource(jedisPool, jedis); 1243 } 1244 return res; 1245 } 1246 1247 /** 1248 * <p> 1249 * 通过key返回list的长度 1250 * </p> 1251 * 1252 * @param key 1253 * @return 1254 */ 1255 public Long llen(String key) { 1256 Jedis jedis = null; 1257 Long res = null; 1258 try { 1259 jedis = jedisPool.getResource(); 1260 res = jedis.llen(key); 1261 } catch (Exception e) { 1262 1263 log.error(e.getMessage()); 1264 } finally { 1265 returnResource(jedisPool, jedis); 1266 } 1267 return res; 1268 } 1269 1270 /** 1271 * <p> 1272 * 通过key获取list指定下标位置的value 1273 * </p> 1274 * <p> 1275 * 如果start 为 0 end 为 -1 则返回全部的list中的value 1276 * </p> 1277 * 1278 * @param key 1279 * @param start 1280 * @param end 1281 * @return 1282 */ 1283 public List<String> lrange(String key, long start, long end, int indexdb) { 1284 Jedis jedis = null; 1285 List<String> res = null; 1286 try { 1287 jedis = jedisPool.getResource(); 1288 jedis.select(indexdb); 1289 res = jedis.lrange(key, start, end); 1290 } catch (Exception e) { 1291 1292 log.error(e.getMessage()); 1293 } finally { 1294 returnResource(jedisPool, jedis); 1295 } 1296 return res; 1297 } 1298 1299 /** 1300 * <p> 1301 * 将列表 key 下标为 index 的元素的值设置为 value 1302 * </p> 1303 * 1304 * @param key 1305 * @param index 1306 * @param value 1307 * @return 操作成功返回 ok ，否则返回错误信息 1308 */ 1309 public String lset(String key, long index, String value) { 1310 Jedis jedis = null; 1311 try { 1312 jedis = jedisPool.getResource(); 1313 return jedis.lset(key, index, value); 1314 } catch (Exception e) { 1315 1316 log.error(e.getMessage()); 1317 } finally { 1318 returnResource(jedisPool, jedis); 1319 } 1320 return null; 1321 } 1322 1323 /** 1324 * <p> 1325 * 返回给定排序后的结果 1326 * </p> 1327 * 1328 * @param key 1329 * @param sortingParameters 1330 * @return 返回列表形式的排序结果 1331 */ 1332 public List<String> sort(String key, SortingParams sortingParameters) { 1333 Jedis jedis = null; 1334 try { 1335 jedis = jedisPool.getResource(); 1336 return jedis.sort(key, sortingParameters); 1337 } catch (Exception e) { 1338 1339 log.error(e.getMessage()); 1340 } finally { 1341 returnResource(jedisPool, jedis); 1342 } 1343 return null; 1344 } 1345 1346 /** 1347 * <p> 1348 * 返回排序后的结果，排序默认以数字作为对象，值被解释为双精度浮点数，然后进行比较。 1349 * </p> 1350 * 1351 * @param key 1352 * @return 返回列表形式的排序结果 1353 */ 1354 public List<String> sort(String key) { 1355 Jedis jedis = null; 1356 try { 1357 jedis = jedisPool.getResource(); 1358 return jedis.sort(key); 1359 } catch (Exception e) { 1360 1361 log.error(e.getMessage()); 1362 } finally { 1363 returnResource(jedisPool, jedis); 1364 } 1365 return null; 1366 } 1367 1368 /** 1369 * <p> 1370 * 通过key向指定的set中添加value 1371 * </p> 1372 * 1373 * @param key 1374 * @param members 1375 * 可以是一个String 也可以是一个String数组 1376 * @return 添加成功的个数 1377 */ 1378 public Long sadd(String key, String... members) { 1379 Jedis jedis = null; 1380 Long res = null; 1381 try { 1382 jedis = jedisPool.getResource(); 1383 res = jedis.sadd(key, members); 1384 } catch (Exception e) { 1385 1386 log.error(e.getMessage()); 1387 } finally { 1388 returnResource(jedisPool, jedis); 1389 } 1390 return res; 1391 } 1392 1393 /** 1394 * <p> 1395 * 通过key删除set中对应的value值 1396 * </p> 1397 * 1398 * @param key 1399 * @param members 1400 * 可以是一个String 也可以是一个String数组 1401 * @return 删除的个数 1402 */ 1403 public Long srem(String key, String... members) { 1404 Jedis jedis = null; 1405 Long res = null; 1406 try { 1407 jedis = jedisPool.getResource(); 1408 res = jedis.srem(key, members); 1409 } catch (Exception e) { 1410 1411 log.error(e.getMessage()); 1412 } finally { 1413 returnResource(jedisPool, jedis); 1414 } 1415 return res; 1416 } 1417 1418 /** 1419 * <p> 1420 * 通过key随机删除一个set中的value并返回该值 1421 * </p> 1422 * 1423 * @param key 1424 * @return 1425 */ 1426 public String spop(String key) { 1427 Jedis jedis = null; 1428 String res = null; 1429 try { 1430 jedis = jedisPool.getResource(); 1431 res = jedis.spop(key); 1432 } catch (Exception e) { 1433 1434 log.error(e.getMessage()); 1435 } finally { 1436 returnResource(jedisPool, jedis); 1437 } 1438 return res; 1439 } 1440 1441 /** 1442 * <p> 1443 * 通过key获取set中的差集 1444 * </p> 1445 * <p> 1446 * 以第一个set为标准 1447 * </p> 1448 * 1449 * @param keys 1450 * 可以使一个string 则返回set中所有的value 也可以是string数组 1451 * @return 1452 */ 1453 public Set<String> sdiff(String... keys) { 1454 Jedis jedis = null; 1455 Set<String> res = null; 1456 try { 1457 jedis = jedisPool.getResource(); 1458 res = jedis.sdiff(keys); 1459 } catch (Exception e) { 1460 1461 log.error(e.getMessage()); 1462 } finally { 1463 returnResource(jedisPool, jedis); 1464 } 1465 return res; 1466 } 1467 1468 /** 1469 * <p> 1470 * 通过key获取set中的差集并存入到另一个key中 1471 * </p> 1472 * <p> 1473 * 以第一个set为标准 1474 * </p> 1475 * 1476 * @param dstkey 1477 * 差集存入的key 1478 * @param keys 1479 * 可以使一个string 则返回set中所有的value 也可以是string数组 1480 * @return 1481 */ 1482 public Long sdiffstore(String dstkey, String... keys) { 1483 Jedis jedis = null; 1484 Long res = null; 1485 try { 1486 jedis = jedisPool.getResource(); 1487 res = jedis.sdiffstore(dstkey, keys); 1488 } catch (Exception e) { 1489 1490 log.error(e.getMessage()); 1491 } finally { 1492 returnResource(jedisPool, jedis); 1493 } 1494 return res; 1495 } 1496 1497 /** 1498 * <p> 1499 * 通过key获取指定set中的交集 1500 * </p> 1501 * 1502 * @param keys 1503 * 可以使一个string 也可以是一个string数组 1504 * @return 1505 */ 1506 public Set<String> sinter(String... keys) { 1507 Jedis jedis = null; 1508 Set<String> res = null; 1509 try { 1510 jedis = jedisPool.getResource(); 1511 res = jedis.sinter(keys); 1512 } catch (Exception e) { 1513 1514 log.error(e.getMessage()); 1515 } finally { 1516 returnResource(jedisPool, jedis); 1517 } 1518 return res; 1519 } 1520 1521 /** 1522 * <p> 1523 * 通过key获取指定set中的交集 并将结果存入新的set中 1524 * </p> 1525 * 1526 * @param dstkey 1527 * @param keys 1528 * 可以使一个string 也可以是一个string数组 1529 * @return 1530 */ 1531 public Long sinterstore(String dstkey, String... keys) { 1532 Jedis jedis = null; 1533 Long res = null; 1534 try { 1535 jedis = jedisPool.getResource(); 1536 res = jedis.sinterstore(dstkey, keys); 1537 } catch (Exception e) { 1538 1539 log.error(e.getMessage()); 1540 } finally { 1541 returnResource(jedisPool, jedis); 1542 } 1543 return res; 1544 } 1545 1546 /** 1547 * <p> 1548 * 通过key返回所有set的并集 1549 * </p> 1550 * 1551 * @param keys 1552 * 可以使一个string 也可以是一个string数组 1553 * @return 1554 */ 1555 public Set<String> sunion(String... keys) { 1556 Jedis jedis = null; 1557 Set<String> res = null; 1558 try { 1559 jedis = jedisPool.getResource(); 1560 res = jedis.sunion(keys); 1561 } catch (Exception e) { 1562 1563 log.error(e.getMessage()); 1564 } finally { 1565 returnResource(jedisPool, jedis); 1566 } 1567 return res; 1568 } 1569 1570 /** 1571 * <p> 1572 * 通过key返回所有set的并集,并存入到新的set中 1573 * </p> 1574 * 1575 * @param dstkey 1576 * @param keys 1577 * 可以使一个string 也可以是一个string数组 1578 * @return 1579 */ 1580 public Long sunionstore(String dstkey, String... keys) { 1581 Jedis jedis = null; 1582 Long res = null; 1583 try { 1584 jedis = jedisPool.getResource(); 1585 res = jedis.sunionstore(dstkey, keys); 1586 } catch (Exception e) { 1587 1588 log.error(e.getMessage()); 1589 } finally { 1590 returnResource(jedisPool, jedis); 1591 } 1592 return res; 1593 } 1594 1595 /** 1596 * <p> 1597 * 通过key将set中的value移除并添加到第二个set中 1598 * </p> 1599 * 1600 * @param srckey 1601 * 需要移除的 1602 * @param dstkey 1603 * 添加的 1604 * @param member 1605 * set中的value 1606 * @return 1607 */ 1608 public Long smove(String srckey, String dstkey, String member) { 1609 Jedis jedis = null; 1610 Long res = null; 1611 try { 1612 jedis = jedisPool.getResource(); 1613 res = jedis.smove(srckey, dstkey, member); 1614 } catch (Exception e) { 1615 1616 log.error(e.getMessage()); 1617 } finally { 1618 returnResource(jedisPool, jedis); 1619 } 1620 return res; 1621 } 1622 1623 /** 1624 * <p> 1625 * 通过key获取set中value的个数 1626 * </p> 1627 * 1628 * @param key 1629 * @return 1630 */ 1631 public Long scard(String key) { 1632 Jedis jedis = null; 1633 Long res = null; 1634 try { 1635 jedis = jedisPool.getResource(); 1636 res = jedis.scard(key); 1637 } catch (Exception e) { 1638 1639 log.error(e.getMessage()); 1640 } finally { 1641 returnResource(jedisPool, jedis); 1642 } 1643 return res; 1644 } 1645 1646 /** 1647 * <p> 1648 * 通过key判断value是否是set中的元素 1649 * </p> 1650 * 1651 * @param key 1652 * @param member 1653 * @return 1654 */ 1655 public Boolean sismember(String key, String member) { 1656 Jedis jedis = null; 1657 Boolean res = null; 1658 try { 1659 jedis = jedisPool.getResource(); 1660 res = jedis.sismember(key, member); 1661 } catch (Exception e) { 1662 1663 log.error(e.getMessage()); 1664 } finally { 1665 returnResource(jedisPool, jedis); 1666 } 1667 return res; 1668 } 1669 1670 /** 1671 * <p> 1672 * 通过key获取set中随机的value,不删除元素 1673 * </p> 1674 * 1675 * @param key 1676 * @return 1677 */ 1678 public String srandmember(String key) { 1679 Jedis jedis = null; 1680 String res = null; 1681 try { 1682 jedis = jedisPool.getResource(); 1683 res = jedis.srandmember(key); 1684 } catch (Exception e) { 1685 1686 log.error(e.getMessage()); 1687 } finally { 1688 returnResource(jedisPool, jedis); 1689 } 1690 return res; 1691 } 1692 1693 /** 1694 * <p> 1695 * 通过key获取set中所有的value 1696 * </p> 1697 * 1698 * @param key 1699 * @return 1700 */ 1701 public Set<String> smembers(String key) { 1702 Jedis jedis = null; 1703 Set<String> res = null; 1704 try { 1705 jedis = jedisPool.getResource(); 1706 res = jedis.smembers(key); 1707 } catch (Exception e) { 1708 1709 log.error(e.getMessage()); 1710 } finally { 1711 returnResource(jedisPool, jedis); 1712 } 1713 return res; 1714 } 1715 1716 /** 1717 * <p> 1718 * 通过key向zset中添加value,score,其中score就是用来排序的 1719 * </p> 1720 * <p> 1721 * 如果该value已经存在则根据score更新元素 1722 * </p> 1723 * 1724 * @param key 1725 * @param score 1726 * @param member 1727 * @return 1728 */ 1729 public Long zadd(String key, double score, String member) { 1730 Jedis jedis = null; 1731 Long res = null; 1732 try { 1733 jedis = jedisPool.getResource(); 1734 res = jedis.zadd(key, score, member); 1735 } catch (Exception e) { 1736 1737 log.error(e.getMessage()); 1738 } finally { 1739 returnResource(jedisPool, jedis); 1740 } 1741 return res; 1742 } 1743 1744 /** 1745 * <p> 1746 * 返回有序集 key 中，指定区间内的成员。min=0,max=-1代表所有元素 1747 * </p> 1748 * 1749 * @param key 1750 * @param min 1751 * @param max 1752 * @return 指定区间内的有序集成员的列表。 1753 */ 1754 public Set<String> zrange(String key, long min, long max) { 1755 Jedis jedis = null; 1756 try { 1757 jedis = jedisPool.getResource(); 1758 return jedis.zrange(key, min, max); 1759 } catch (Exception e) { 1760 1761 log.error(e.getMessage()); 1762 } finally { 1763 returnResource(jedisPool, jedis); 1764 } 1765 return null; 1766 } 1767 1768 /** 1769 * <p> 1770 * 统计有序集 key 中,值在 min 和 max 之间的成员的数量 1771 * </p> 1772 * 1773 * @param key 1774 * @param min 1775 * @param max 1776 * @return 值在 min 和 max 之间的成员的数量。异常返回0 1777 */ 1778 public Long zcount(String key, double min, double max) { 1779 Jedis jedis = null; 1780 try { 1781 jedis = jedisPool.getResource(); 1782 return jedis.zcount(key, min, max); 1783 } catch (Exception e) { 1784 1785 log.error(e.getMessage()); 1786 return 0L; 1787 } finally { 1788 returnResource(jedisPool, jedis); 1789 } 1790 1791 } 1792 1793 /** 1794 * <p> 1795 * 为哈希表 key 中的域 field 的值加上增量 increment 。增量也可以为负数，相当于对给定域进行减法操作。 如果 key 1796 * 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。如果域 field 不存在，那么在执行命令前，域的值被初始化为 0 。 1797 * 对一个储存字符串值的域 field 执行 HINCRBY 命令将造成一个错误。本操作的值被限制在 64 位(bit)有符号数字表示之内。 1798 * </p> 1799 * <p> 1800 * 将名称为key的hash中field的value增加integer 1801 * </p> 1802 * 1803 * @param key 1804 * @param value 1805 * @param increment 1806 * @return 执行 HINCRBY 命令之后，哈希表 key 中域 field的值。异常返回0 1807 */ 1808 public Long hincrBy(String key, String value, long increment) { 1809 Jedis jedis = null; 1810 try { 1811 jedis = jedisPool.getResource(); 1812 return jedis.hincrBy(key, value, increment); 1813 } catch (Exception e) { 1814 log.error(e.getMessage()); 1815 return 0L; 1816 } finally { 1817 returnResource(jedisPool, jedis); 1818 } 1819 1820 } 1821 1822 /** 1823 * <p> 1824 * 通过key删除在zset中指定的value 1825 * </p> 1826 * 1827 * @param key 1828 * @param members 1829 * 可以使一个string 也可以是一个string数组 1830 * @return 1831 */ 1832 public Long zrem(String key, String... members) { 1833 Jedis jedis = null; 1834 Long res = null; 1835 try { 1836 jedis = jedisPool.getResource(); 1837 res = jedis.zrem(key, members); 1838 } catch (Exception e) { 1839 1840 log.error(e.getMessage()); 1841 } finally { 1842 returnResource(jedisPool, jedis); 1843 } 1844 return res; 1845 } 1846 1847 /** 1848 * <p> 1849 * 通过key增加该zset中value的score的值 1850 * </p> 1851 * 1852 * @param key 1853 * @param score 1854 * @param member 1855 * @return 1856 */ 1857 public Double zincrby(String key, double score, String member) { 1858 Jedis jedis = null; 1859 Double res = null; 1860 try { 1861 jedis = jedisPool.getResource(); 1862 res = jedis.zincrby(key, score, member); 1863 } catch (Exception e) { 1864 1865 log.error(e.getMessage()); 1866 } finally { 1867 returnResource(jedisPool, jedis); 1868 } 1869 return res; 1870 } 1871 1872 /** 1873 * <p> 1874 * 通过key返回zset中value的排名 1875 * </p> 1876 * <p> 1877 * 下标从小到大排序 1878 * </p> 1879 * 1880 * @param key 1881 * @param member 1882 * @return 1883 */ 1884 public Long zrank(String key, String member) { 1885 Jedis jedis = null; 1886 Long res = null; 1887 try { 1888 jedis = jedisPool.getResource(); 1889 res = jedis.zrank(key, member); 1890 } catch (Exception e) { 1891 1892 log.error(e.getMessage()); 1893 } finally { 1894 returnResource(jedisPool, jedis); 1895 } 1896 return res; 1897 } 1898 1899 /** 1900 * <p> 1901 * 通过key返回zset中value的排名 1902 * </p> 1903 * <p> 1904 * 下标从大到小排序 1905 * </p> 1906 * 1907 * @param key 1908 * @param member 1909 * @return 1910 */ 1911 public Long zrevrank(String key, String member) { 1912 Jedis jedis = null; 1913 Long res = null; 1914 try { 1915 jedis = jedisPool.getResource(); 1916 res = jedis.zrevrank(key, member); 1917 } catch (Exception e) { 1918 1919 log.error(e.getMessage()); 1920 } finally { 1921 returnResource(jedisPool, jedis); 1922 } 1923 return res; 1924 } 1925 1926 /** 1927 * <p> 1928 * 通过key将获取score从start到end中zset的value 1929 * </p> 1930 * <p> 1931 * socre从大到小排序 1932 * </p> 1933 * <p> 1934 * 当start为0 end为-1时返回全部 1935 * </p> 1936 * 1937 * @param key 1938 * @param start 1939 * @param end 1940 * @return 1941 */ 1942 public Set<String> zrevrange(String key, long start, long end) { 1943 Jedis jedis = null; 1944 Set<String> res = null; 1945 try { 1946 jedis = jedisPool.getResource(); 1947 res = jedis.zrevrange(key, start, end); 1948 } catch (Exception e) { 1949 1950 log.error(e.getMessage()); 1951 } finally { 1952 returnResource(jedisPool, jedis); 1953 } 1954 return res; 1955 } 1956 1957 /** 1958 * <p> 1959 * 通过key返回指定score内zset中的value 1960 * </p> 1961 * 1962 * @param key 1963 * @param max 1964 * @param min 1965 * @return 1966 */ 1967 public Set<String> zrangebyscore(String key, String max, String min) { 1968 Jedis jedis = null; 1969 Set<String> res = null; 1970 try { 1971 jedis = jedisPool.getResource(); 1972 res = jedis.zrevrangeByScore(key, max, min); 1973 } catch (Exception e) { 1974 1975 log.error(e.getMessage()); 1976 } finally { 1977 returnResource(jedisPool, jedis); 1978 } 1979 return res; 1980 } 1981 1982 /** 1983 * <p> 1984 * 通过key返回指定score内zset中的value 1985 * </p> 1986 * 1987 * @param key 1988 * @param max 1989 * @param min 1990 * @return 1991 */ 1992 public Set<String> zrangeByScore(String key, double max, double min) { 1993 Jedis jedis = null; 1994 Set<String> res = null; 1995 try { 1996 jedis = jedisPool.getResource(); 1997 res = jedis.zrevrangeByScore(key, max, min); 1998 } catch (Exception e) { 1999 2000 log.error(e.getMessage()); 2001 } finally { 2002 returnResource(jedisPool, jedis); 2003 } 2004 return res; 2005 } 2006 2007 /** 2008 * <p> 2009 * 返回指定区间内zset中value的数量 2010 * </p> 2011 * 2012 * @param key 2013 * @param min 2014 * @param max 2015 * @return 2016 */ 2017 public Long zcount(String key, String min, String max) { 2018 Jedis jedis = null; 2019 Long res = null; 2020 try { 2021 jedis = jedisPool.getResource(); 2022 res = jedis.zcount(key, min, max); 2023 } catch (Exception e) { 2024 2025 log.error(e.getMessage()); 2026 } finally { 2027 returnResource(jedisPool, jedis); 2028 } 2029 return res; 2030 } 2031 2032 /** 2033 * <p> 2034 * 通过key返回zset中的value个数 2035 * </p> 2036 * 2037 * @param key 2038 * @return 2039 */ 2040 public Long zcard(String key) { 2041 Jedis jedis = null; 2042 Long res = null; 2043 try { 2044 jedis = jedisPool.getResource(); 2045 res = jedis.zcard(key); 2046 } catch (Exception e) { 2047 2048 log.error(e.getMessage()); 2049 } finally { 2050 returnResource(jedisPool, jedis); 2051 } 2052 return res; 2053 } 2054 2055 /** 2056 * <p> 2057 * 通过key获取zset中value的score值 2058 * </p> 2059 * 2060 * @param key 2061 * @param member 2062 * @return 2063 */ 2064 public Double zscore(String key, String member) { 2065 Jedis jedis = null; 2066 Double res = null; 2067 try { 2068 jedis = jedisPool.getResource(); 2069 res = jedis.zscore(key, member); 2070 } catch (Exception e) { 2071 2072 log.error(e.getMessage()); 2073 } finally { 2074 returnResource(jedisPool, jedis); 2075 } 2076 return res; 2077 } 2078 2079 /** 2080 * <p> 2081 * 通过key删除给定区间内的元素 2082 * </p> 2083 * 2084 * @param key 2085 * @param start 2086 * @param end 2087 * @return 2088 */ 2089 public Long zremrangeByRank(String key, long start, long end) { 2090 Jedis jedis = null; 2091 Long res = null; 2092 try { 2093 jedis = jedisPool.getResource(); 2094 res = jedis.zremrangeByRank(key, start, end); 2095 } catch (Exception e) { 2096 2097 log.error(e.getMessage()); 2098 } finally { 2099 returnResource(jedisPool, jedis); 2100 } 2101 return res; 2102 } 2103 2104 /** 2105 * <p> 2106 * 通过key删除指定score内的元素 2107 * </p> 2108 * 2109 * @param key 2110 * @param start 2111 * @param end 2112 * @return 2113 */ 2114 public Long zremrangeByScore(String key, double start, double end) { 2115 Jedis jedis = null; 2116 Long res = null; 2117 try { 2118 jedis = jedisPool.getResource(); 2119 res = jedis.zremrangeByScore(key, start, end); 2120 } catch (Exception e) { 2121 2122 log.error(e.getMessage()); 2123 } finally { 2124 returnResource(jedisPool, jedis); 2125 } 2126 return res; 2127 } 2128 2129 /** 2130 * <p> 2131 * 返回满足pattern表达式的所有key 2132 * </p> 2133 * <p> 2134 * keys(*) 2135 * </p> 2136 * <p> 2137 * 返回所有的key 2138 * </p> 2139 * 2140 * @param pattern 2141 * @return 2142 */ 2143 public Set<String> keys(String pattern) { 2144 Jedis jedis = null; 2145 Set<String> res = null; 2146 try { 2147 jedis = jedisPool.getResource(); 2148 res = jedis.keys(pattern); 2149 } catch (Exception e) { 2150 2151 log.error(e.getMessage()); 2152 } finally { 2153 returnResource(jedisPool, jedis); 2154 } 2155 return res; 2156 } 2157 2158 public Set<String> keysBySelect(String pattern,int database) { 2159 Jedis jedis = null; 2160 Set<String> res = null; 2161 try { 2162 jedis = jedisPool.getResource(); 2163 jedis.select(database); 2164 res = jedis.keys(pattern); 2165 } catch (Exception e) { 2166 2167 log.error(e.getMessage()); 2168 } finally { 2169 returnResource(jedisPool, jedis); 2170 } 2171 return res; 2172 } 2173 2174 2175 /** 2176 * 通过key判断值得类型 2177 * @param key 2178 * @return 2179 */ 2180 public String type(String key) { 2181 Jedis jedis = null; 2182 String res = null; 2183 try { 2184 jedis = jedisPool.getResource(); 2185 res = jedis.type(key); 2186 } catch (Exception e) { 2187 2188 log.error(e.getMessage()); 2189 } finally { 2190 returnResource(jedisPool, jedis); 2191 } 2192 return res; 2193 } 2194 2195 /** 2196 * 序列化对象 2197 * @param obj 2198 * @return 2199 * 对象需实现Serializable接口 2200 */ 2201 public static byte[] ObjTOSerialize(Object obj) { 2202 ObjectOutputStream oos = null; 2203 ByteArrayOutputStream byteOut = null; 2204 try { 2205 byteOut = new ByteArrayOutputStream(); 2206 oos = new ObjectOutputStream(byteOut); 2207 oos.writeObject(obj); 2208 byte[] bytes = byteOut.toByteArray(); 2209 return bytes; 2210 } catch (Exception e) { 2211 } 2212 return null; 2213 } 2214 2215 /** 2216 * 反序列化对象 2217 * @param bytes 2218 * @return 2219 * 对象需实现Serializable接口 2220 */ 2221 public static Object unserialize(byte[] bytes) { 2222 ByteArrayInputStream bais = null; 2223 try { 2224 //反序列化 2225 bais = new ByteArrayInputStream(bytes); 2226 ObjectInputStream ois = new ObjectInputStream(bais); 2227 return ois.readObject(); 2228 } catch (Exception e) { 2229 } 2230 return null; 2231 } 2232 2233 /** 2234 * 返还到连接池 2235 * 2236 * @param jedisPool 2237 * @param jedis 2238 */ 2239 public static void returnResource(JedisPool jedisPool, Jedis jedis) { 2240 if (jedis != null) { 2241 jedisPool.returnResource(jedis); 2242 } 2243 } 2244 }
application.properties
1 # Redis数据库索引（默认为0） 2 spring.redis.database=0 3 # Redis服务器地址 4 spring.redis.host=127.0.0.1 5 # Redis服务器连接端口 6 spring.redis.port=6379 7 # Redis服务器连接密码（默认为空） 8 spring.redis.password= 9 # 连接超时时间（毫秒） 10 spring.redis.timeout=1000 11 12 # 连接池最大连接数（使用负值表示没有限制） 13 spring.redis.jedis.pool.max-active=200 14 # 连接池最大阻塞等待时间（使用负值表示没有限制） 15 spring.redis.jedis.pool.max-wait=1000 16 # 连接池中的最大空闲连接 17 spring.redis.jedis.pool.max-idle=8 18 # 连接池中的最小空闲连接 19 spring.redis.jedis.pool.min-idle=0 20 # 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true 21 spring.redis.block-when-exhausted=true
Jedis单元测试
1 import com.example.redis.pojo.User; 2 import com.example.redis.util.JedisUtil; 3 import com.example.redis.util.SerializeUtil; 4 import org.junit.Test; 5 import org.junit.runner.RunWith; 6 import org.springframework.beans.factory.annotation.Autowired; 7 import org.springframework.boot.test.context.SpringBootTest; 8 import org.springframework.data.redis.core.RedisTemplate; 9 import org.springframework.data.redis.core.ValueOperations; 10 import org.springframework.test.context.junit4.SpringRunner; 11 import redis.clients.jedis.JedisPool; 12 import java.io.IOException; 13 14 @RunWith(SpringRunner.class) 15 @SpringBootTest 16 public class RedisApplicationTests { 17 18 @Autowired 19 private JedisUtil redisUtil; 20 @Autowired 21 private SerializeUtil serializeUtil; 22 @Autowired 23 private JedisPool jedisPool; 24 25 /** 26 * 測試jedis連接池 27 */ 28 @Test 29 public void testJedis() { 30 User user = new User(1L, "問女何所思", "000000002", "123456"); 31 User user1 = new User(1L, "問女何所憶", "000000003", "123456"); 32 String set = redisUtil.set("qq".getBytes(), serializeUtil.serialize(user), 0); 33 //jedisPool.getResource().set("qq".getBytes(), serializeUtil.serialize(user)); 34 String set1 = redisUtil.set("weixin".getBytes(), serializeUtil.serialize(user1), 0); 35 //jedisPool.getResource().set("weixin".getBytes(), serializeUtil.serialize(user1)); 36 37 byte[] bytes = redisUtil.get("qq".getBytes(), 0); 38 System.out.println("redis存放結果: " + bytes); 39 byte[] bytes1 = redisUtil.get("weixin".getBytes(), 0); 40 System.out.println("redis存放結果: " + bytes1); 41 try { 42 User user2 = (User)serializeUtil.deserialize(bytes); 43 System.out.println(user2); 44 45 User user3 = (User)serializeUtil.deserialize(bytes1); 46 System.out.println(user3); 47 } catch (IOException e) { 48 e.printStackTrace(); 49 } catch (ClassNotFoundException e) { 50 e.printStackTrace(); 51 } 52 } 53 54 }
SpringBoot集成Lettuce连接池：
1 <dependency> 2 <groupId>org.springframework.boot</groupId> 3 <artifactId>spring-boot-starter-data-redis</artifactId> 4 </dependency> 5 6 <!--lettuce pool連接池--> 7 <dependency> 8 <groupId>org.apache.commons</groupId> 9 <artifactId>commons-pool2</artifactId> 10 </dependency>
RedisConfig
1 import org.springframework.context.annotation.Bean; 2 import org.springframework.context.annotation.Configuration; 3 import org.springframework.data.redis.connection.jedis.JedisConnectionFactory; 4 import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; 5 import org.springframework.data.redis.core.RedisTemplate; 6 import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer; 7 import org.springframework.data.redis.serializer.StringRedisSerializer; 8 import java.io.Serializable; 9 10 @Configuration 11 public class RedisConfig { 12 13 @Bean 14 public RedisTemplate<String, Serializable> redisTemplate(LettuceConnectionFactory connectionFactory) { 15 RedisTemplate<String, Serializable> redisTemplate = new RedisTemplate<>(); 16 redisTemplate.setKeySerializer(new StringRedisSerializer()); 17 redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer()); 18 redisTemplate.setConnectionFactory(connectionFactory); 19 //redisTemplate.setConnectionFactory(new JedisConnectionFactory()); 20 return redisTemplate; 21 } 22 23 }
application.properties
1 # Redis数据库索引（默认为0） 2 spring.redis.database=0 3 # Redis服务器地址 4 spring.redis.host=127.0.0.1 5 # Redis服务器连接端口 6 spring.redis.port=6379 7 # Redis服务器连接密码（默认为空） 8 spring.redis.password= 9 # 连接池最大连接数（使用负值表示没有限制） 10 spring.redis.lettuce.pool.max-active=200 11 # 连接池最大阻塞等待时间（使用负值表示没有限制） 12 spring.redis.lettuce.pool.max-wait=-1 13 # 连接池中的最大空闲连接 14 spring.redis.lettuce.pool.max-idle=10 15 # 连接池中的最小空闲连接 16 spring.redis.lettuce.pool.min-idle=0 17 # 连接超时时间（毫秒） 18 spring.redis.timeout=1000
Lettuce单元测试
1 import com.example.redis.pojo.User; 2 import com.example.redis.util.JedisUtil; 3 import com.example.redis.util.SerializeUtil; 4 import org.junit.Test; 5 import org.junit.runner.RunWith; 6 import org.springframework.beans.factory.annotation.Autowired; 7 import org.springframework.boot.test.context.SpringBootTest; 8 import org.springframework.data.redis.core.RedisTemplate; 9 import org.springframework.data.redis.core.ValueOperations; 10 import org.springframework.test.context.junit4.SpringRunner; 11 import redis.clients.jedis.JedisPool; 12 import java.io.IOException; 13 14 @RunWith(SpringRunner.class) 15 @SpringBootTest 16 public class RedisApplicationTests { 17 18 @Autowired 19 private RedisTemplate redisTemplate; 20 21 /** 22 * 測試redisTemplate 23 */ 24 @Test 25 public void contextLoads() { 26 User user = new User(1L, "666先生的救贖", "000000001", "123456"); 27 ValueOperations<String, User> operations = redisTemplate.opsForValue(); 28 operations.set("maxinhai", user); 29 Boolean exists = redisTemplate.hasKey("maxinhai"); 30 System.out.println("redis是否在存在相應的key: " + exists); 31 User user1 = (User)redisTemplate.opsForValue().get("maxinhai"); 32 System.out.println(user1); 33 } 34 35 }
redis存储的对象要实现Serializable接口。
原文：https://www.cnblogs.com/mxh-java/p/12310408.html