Redis连接池Lettuce Jedis 区别

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接口。

posted @ 2020-02-15 00:39 尘世间迷茫的小书童阅读(8152) 评论(0) 编辑收藏举报

刷新页面返回顶部

尘世间迷茫的小书童

Redis连接池Lettuce Jedis 区别

公告